From f8833c443d047f0c8dac5710e52b4c0624fc52ce Mon Sep 17 00:00:00 2001
From: Andrew McKnight <andrew.mcknight@sentry.io>
Date: Fri, 16 Feb 2024 21:10:26 +0800
Subject: [PATCH] feat(app launch profiling): add app launch profiling (#3529)

---
 CHANGELOG.md                                  |   5 +
 .../xcshareddata/xcschemes/iOS-Swift.xcscheme |  22 +-
 .../xcschemes/iOS-SwiftUITests.xcscheme       |   2 +-
 Samples/iOS-Swift/iOS-Swift/AppDelegate.swift |  17 +-
 .../iOS-Swift/Base.lproj/Main.storyboard      |  62 +++-
 .../Profiling/ProfilingViewController.swift   | 106 ++++--
 .../TransactionsViewController.swift          |  37 +-
 .../iOS-SwiftUITests/BaseUITest.swift         |  32 +-
 .../iOS-SwiftUITests/ProfilingUITests.swift   | 266 ++++++++++++--
 .../iOS-SwiftUI.xcodeproj/project.pbxproj     | 122 +++++++
 Sentry.xcodeproj/project.pbxproj              |  52 +--
 .../SentryTestUtils-ObjC-BridgingHeader.h     |   2 +-
 .../Sentry/Profiling/SentryLaunchProfiling.m  | 169 +++++++++
 .../Sentry/Profiling/SentryProfilerState.mm   |  11 +-
 Sources/Sentry/Public/SentryOptions.h         |  22 +-
 .../Sentry/Public/SentryTransactionContext.h  |   9 +
 Sources/Sentry/SentryFileManager.m            | 153 ++++++--
 Sources/Sentry/SentryHub.m                    |  28 +-
 Sources/Sentry/SentryLog.m                    |   7 +-
 Sources/Sentry/SentryOptions.m                |  50 +--
 Sources/Sentry/SentryProfileTimeseries.mm     |   2 +
 Sources/Sentry/SentryProfiler.mm              |  88 ++++-
 Sources/Sentry/SentryProfilesSampler.m        |  93 -----
 Sources/Sentry/SentrySDK.m                    |  19 +-
 Sources/Sentry/SentrySamplerDecision.m        |  15 +
 Sources/Sentry/SentrySampling.m               | 117 ++++++
 Sources/Sentry/SentryTracer.m                 |  45 ++-
 Sources/Sentry/SentryTracesSampler.m          |  84 -----
 Sources/Sentry/include/SentryFileManager.h    |  39 ++
 .../Sentry/include/SentryInternalDefines.h    |   8 +-
 .../Sentry/include/SentryLaunchProfiling.h    |  33 ++
 .../Sentry/include/SentryOptions+Private.h    |  12 +-
 .../Sentry/include/SentryProfilesSampler.h    |  55 ---
 .../Sentry/include/SentrySamplerDecision.h    |  17 +
 Sources/Sentry/include/SentrySampling.h       |  24 ++
 Sources/Sentry/include/SentryTraceOrigins.h   |   1 +
 Sources/Sentry/include/SentryTracer.h         |  13 +-
 .../include/SentryTracerConfiguration.h       |   6 +-
 Sources/Sentry/include/SentryTracesSampler.h  |  46 ---
 .../SentryAppLaunchProfilingTests.m           | 151 ++++++++
 .../SentryProfilerSwiftTests.swift            |  58 ++-
 .../SentryProfilerTests.mm                    |   2 +-
 ...tProperties.h => SentryFileManager+Test.h} |   3 +
 .../Helper/SentryFileManagerTests.swift       | 332 ++++++++++++------
 Tests/SentryTests/SentryHubTests.swift        |  19 +-
 .../SentryTests/SentryLaunchProfiling+Tests.h |  27 ++
 Tests/SentryTests/SentryOptionsTest.m         |  27 +-
 Tests/SentryTests/SentrySDK+Tests.h           |   8 +-
 .../SentryTests/SentryTests-Bridging-Header.h |   3 +-
 .../Transaction/SentryTracerObjCTests.m       |   1 -
 develop-docs/README.md                        |  16 +
 51 files changed, 1883 insertions(+), 655 deletions(-)
 create mode 100644 Sources/Sentry/Profiling/SentryLaunchProfiling.m
 delete mode 100644 Sources/Sentry/SentryProfilesSampler.m
 create mode 100644 Sources/Sentry/SentrySamplerDecision.m
 create mode 100644 Sources/Sentry/SentrySampling.m
 delete mode 100644 Sources/Sentry/SentryTracesSampler.m
 create mode 100644 Sources/Sentry/include/SentryLaunchProfiling.h
 delete mode 100644 Sources/Sentry/include/SentryProfilesSampler.h
 create mode 100644 Sources/Sentry/include/SentrySamplerDecision.h
 create mode 100644 Sources/Sentry/include/SentrySampling.h
 delete mode 100644 Sources/Sentry/include/SentryTracesSampler.h
 create mode 100644 Tests/SentryProfilerTests/SentryAppLaunchProfilingTests.m
 rename Tests/SentryTests/Helper/{SentryFileManager+TestProperties.h => SentryFileManager+Test.h} (72%)
 create mode 100644 Tests/SentryTests/SentryLaunchProfiling+Tests.h

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 842aff2a95d..09733f266e0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Features
+
+- Automatically profile app launches (#3529)
+
 ### Improvements
 
 - Cache installationID async to avoid file IO on the main thread when starting the SDK (#3601)
@@ -10,6 +14,7 @@
 ### Fixes
 
 - Finish TTID span when transaction finishes (#3610)
+- Don't take screenshot and view hierarchy for app hanging (#3620)
 - Dont take screenshot and view hierarchy for app hanging (#3620)
 - Remove `free_storage` and `storage_size` from the device context (#3627), because Apple forbids sending
 information retrieved via `NSFileSystemFreeSize` and `NSFileSystemSize` off a device; see
diff --git a/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-Swift.xcscheme b/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-Swift.xcscheme
index fa07f21b626..dc3a836c25c 100644
--- a/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-Swift.xcscheme
+++ b/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-Swift.xcscheme
@@ -23,7 +23,7 @@
       </BuildActionEntries>
    </BuildAction>
    <TestAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Test"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       shouldUseLaunchSchemeArgsEnv = "YES">
@@ -73,6 +73,26 @@
             argument = "--disable-file-io-tracing"
             isEnabled = "NO">
          </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--io.sentry.wipe-data"
+            isEnabled = "YES">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--io.sentry.slow-load-method"
+            isEnabled = "YES">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--disable-watchdog-tracking"
+            isEnabled = "NO">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--disable-tracing"
+            isEnabled = "NO">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--profile-app-launches"
+            isEnabled = "YES">
+         </CommandLineArgument>
          <CommandLineArgument
             argument = "--disable-crash-handler"
             isEnabled = "NO">
diff --git a/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-SwiftUITests.xcscheme b/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-SwiftUITests.xcscheme
index 55e1974867d..37a4ca1e81a 100644
--- a/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-SwiftUITests.xcscheme
+++ b/Samples/iOS-Swift/iOS-Swift.xcodeproj/xcshareddata/xcschemes/iOS-SwiftUITests.xcscheme
@@ -25,7 +25,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Test"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       launchStyle = "0"
diff --git a/Samples/iOS-Swift/iOS-Swift/AppDelegate.swift b/Samples/iOS-Swift/iOS-Swift/AppDelegate.swift
index 9379c6e4f8a..e4eaf21e211 100644
--- a/Samples/iOS-Swift/iOS-Swift/AppDelegate.swift
+++ b/Samples/iOS-Swift/iOS-Swift/AppDelegate.swift
@@ -34,7 +34,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
             }
             options.tracesSampleRate = tracesSampleRate
             
-            if let tracesSamplerValue = env["--io.sentry.tracersSamplerValue"] {
+            if let tracesSamplerValue = env["--io.sentry.tracesSamplerValue"] {
                 options.tracesSampler = { _ in
                     return NSNumber(value: (tracesSamplerValue as NSString).integerValue)
                 }
@@ -51,7 +51,9 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
                     return NSNumber(value: (profilesSamplerValue as NSString).integerValue)
                 }
             }
-                        
+
+            options.enableAppLaunchProfiling = args.contains("--profile-app-launches")
+
             options.sessionTrackingIntervalMillis = 5_000
             options.attachScreenshot = true
             options.attachViewHierarchy = true
@@ -81,9 +83,11 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
             options.enableNetworkBreadcrumbs = !args.contains("--disable-network-breadcrumbs")
             options.enableSwizzling = !args.contains("--disable-swizzling")
             options.enableCrashHandler = !args.contains("--disable-crash-handler")
+            options.enableTracing = !args.contains("--disable-tracing")
 
             // because we run CPU for 15 seconds at full throttle, we trigger ANR issues being sent. disable such during benchmarks.
             options.enableAppHangTracking = !isBenchmarking && !args.contains("--disable-anr-tracking")
+            options.enableWatchdogTerminationTracking = !isBenchmarking && !args.contains("--disable-watchdog-tracking")
             options.appHangTimeoutInterval = 2
             options.enableCaptureFailedRequests = true
             let httpStatusCodeRange = HttpStatusCodeRange(min: 400, max: 599)
@@ -96,7 +100,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
             }
             
             options.initialScope = { scope in
-                let processInfoEnvironment = ProcessInfo.processInfo.environment["io.sentry.sdk-environment"]
+                let processInfoEnvironment = env["io.sentry.sdk-environment"]
                 
                 if processInfoEnvironment != nil {
                     scope.setEnvironment(processInfoEnvironment)
@@ -126,8 +130,8 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
         
-        print("[iOS-Swift] launch arguments: \(ProcessInfo.processInfo.arguments)")
-        print("[iOS-Swift] environment: \(ProcessInfo.processInfo.environment)")
+        print("[iOS-Swift] [debug] launch arguments: \(ProcessInfo.processInfo.arguments)")
+        print("[iOS-Swift] [debug] environment: \(ProcessInfo.processInfo.environment)")
         
         maybeWipeData()
         AppDelegate.startSentry()
@@ -161,9 +165,10 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 }
 
 private extension AppDelegate {
+    // previously tried putting this in an AppDelegate.load override in ObjC, but it wouldn't run until after a launch profiler would have an opportunity to run, since SentryProfiler.load would always run first due to being dynamically linked in a framework module. it is sufficient to do it before calling SentrySDK.startWithOptions to clear state for testProfiledAppLaunches because we don't make any assertions on a launch profile the first launch of the app in that test 
     func maybeWipeData() {
         if ProcessInfo.processInfo.arguments.contains("--io.sentry.wipe-data") {
-            print("[iOS-Swift] removing app data")
+            print("[iOS-Swift] [debug] removing app data")
             let appSupport = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).first!
             let cache = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).first!
             for path in [appSupport, cache] {
diff --git a/Samples/iOS-Swift/iOS-Swift/Base.lproj/Main.storyboard b/Samples/iOS-Swift/iOS-Swift/Base.lproj/Main.storyboard
index 094218d85bd..67696810cb6 100644
--- a/Samples/iOS-Swift/iOS-Swift/Base.lproj/Main.storyboard
+++ b/Samples/iOS-Swift/iOS-Swift/Base.lproj/Main.storyboard
@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="22154" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="5CD-RQ-aBU">
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="22505" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="5CD-RQ-aBU">
     <device id="retina4_0" orientation="portrait" appearance="light"/>
     <dependencies>
         <deployment identifier="iOS"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="22130"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="22504"/>
         <capability name="Image references" minToolsVersion="12.0"/>
         <capability name="Safe area layout guides" minToolsVersion="9.0"/>
         <capability name="System colors in document resources" minToolsVersion="11.0"/>
@@ -172,7 +172,7 @@
                         <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
                         <subviews>
                             <stackView opaque="NO" contentMode="scaleToFill" axis="vertical" alignment="center" translatesAutoresizingMaskIntoConstraints="NO" id="jya-5z-xKN">
-                                <rect key="frame" x="0.0" y="64" width="320" height="56"/>
+                                <rect key="frame" x="0.0" y="64" width="320" height="190"/>
                                 <subviews>
                                     <stackView opaque="NO" contentMode="scaleToFill" alignment="center" translatesAutoresizingMaskIntoConstraints="NO" id="DOu-47-e6X">
                                         <rect key="frame" x="93" y="0.0" width="134" height="28"/>
@@ -223,8 +223,57 @@
                                             </button>
                                         </subviews>
                                     </stackView>
+                                    <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="system" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="vwa-d9-1BM">
+                                        <rect key="frame" x="111.5" y="56" width="97" height="28"/>
+                                        <fontDescription key="fontDescription" type="system" pointSize="13"/>
+                                        <inset key="imageEdgeInsets" minX="0.0" minY="0.0" maxX="2.2250738585072014e-308" maxY="0.0"/>
+                                        <state key="normal" title="View last profile"/>
+                                        <connections>
+                                            <action selector="viewLastProfile:" destination="NZr-bH-g9o" eventType="touchUpInside" id="7Xd-19-rsP"/>
+                                        </connections>
+                                    </button>
+                                    <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="system" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="keL-m5-7hv">
+                                        <rect key="frame" x="33.5" y="84" width="253" height="28"/>
+                                        <fontDescription key="fontDescription" type="system" pointSize="13"/>
+                                        <inset key="imageEdgeInsets" minX="0.0" minY="0.0" maxX="2.2250738585072014e-308" maxY="0.0"/>
+                                        <state key="normal" title="Check launch profile marker file existence"/>
+                                        <connections>
+                                            <action selector="checkLaunchProfilingMarkerFile:" destination="NZr-bH-g9o" eventType="touchUpInside" id="IcT-D3-Oya"/>
+                                        </connections>
+                                    </button>
+                                    <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="system" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="F1h-qu-BzX">
+                                        <rect key="frame" x="102.5" y="112" width="115" height="28"/>
+                                        <fontDescription key="fontDescription" type="system" pointSize="13"/>
+                                        <inset key="imageEdgeInsets" minX="0.0" minY="0.0" maxX="2.2250738585072014e-308" maxY="0.0"/>
+                                        <state key="normal" title="View launch profile"/>
+                                        <connections>
+                                            <action selector="viewLaunchProfile:" destination="NZr-bH-g9o" eventType="touchUpInside" id="DPn-8C-b7l"/>
+                                        </connections>
+                                    </button>
+                                    <stackView opaque="NO" contentMode="scaleToFill" alignment="center" spacing="8" translatesAutoresizingMaskIntoConstraints="NO" id="LIr-jM-FSX">
+                                        <rect key="frame" x="19" y="140" width="282" height="50"/>
+                                        <subviews>
+                                            <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="UI test data marshalling:" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="Uhg-B3-Rao" userLabel="UI test data marshaling:">
+                                                <rect key="frame" x="0.0" y="15" width="184" height="20.5"/>
+                                                <fontDescription key="fontDescription" type="system" pointSize="17"/>
+                                                <nil key="textColor"/>
+                                                <nil key="highlightedColor"/>
+                                            </label>
+                                            <textField opaque="NO" contentMode="scaleToFill" horizontalHuggingPriority="248" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" textAlignment="natural" minimumFontSize="17" translatesAutoresizingMaskIntoConstraints="NO" id="5zI-Ix-rMJ">
+                                                <rect key="frame" x="192" y="8" width="32" height="34"/>
+                                                <fontDescription key="fontDescription" type="system" pointSize="14"/>
+                                                <textInputTraits key="textInputTraits"/>
+                                            </textField>
+                                            <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="2LR-W8-mNE" userLabel="Profiling UI Test Data Marshaling status">
+                                                <rect key="frame" x="232" y="0.0" width="50" height="50"/>
+                                                <fontDescription key="fontDescription" type="system" pointSize="17"/>
+                                                <nil key="textColor"/>
+                                                <nil key="highlightedColor"/>
+                                            </label>
+                                        </subviews>
+                                    </stackView>
                                     <textField hidden="YES" opaque="NO" contentMode="scaleToFill" horizontalHuggingPriority="248" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" textAlignment="natural" minimumFontSize="17" translatesAutoresizingMaskIntoConstraints="NO" id="uTM-T7-Gv6">
-                                        <rect key="frame" x="0.0" y="56" width="320" height="0.0"/>
+                                        <rect key="frame" x="0.0" y="190" width="320" height="0.0"/>
                                         <accessibility key="accessibilityConfiguration" identifier="io.sentry.benchmark.value-marshaling-text-field"/>
                                         <fontDescription key="fontDescription" type="system" pointSize="14"/>
                                         <textInputTraits key="textInputTraits"/>
@@ -232,7 +281,7 @@
                                 </subviews>
                             </stackView>
                             <stackView opaque="NO" contentMode="scaleToFill" axis="vertical" alignment="center" translatesAutoresizingMaskIntoConstraints="NO" id="hFG-bX-qLp">
-                                <rect key="frame" x="10" y="174" width="300" height="159.5"/>
+                                <rect key="frame" x="10" y="308" width="300" height="159.5"/>
                                 <subviews>
                                     <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Work threads:" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="t2C-jL-6qO">
                                         <rect key="frame" x="97" y="0.0" width="106.5" height="20.5"/>
@@ -342,10 +391,13 @@
                     </view>
                     <tabBarItem key="tabBarItem" title="Profiling" image="flame.fill" catalog="system" selectedImage="flame.fill" id="Wfx-IJ-h9f"/>
                     <connections>
+                        <outlet property="launchProfilingMarkerFileCheckButton" destination="keL-m5-7hv" id="s2U-XE-Flv"/>
                         <outlet property="maxThreadsTextField" destination="COd-X5-alN" id="6Pn-Be-aUe"/>
                         <outlet property="maxWorkIntensityTextField" destination="rJh-QS-fAl" id="u9q-Sj-6SY"/>
                         <outlet property="minThreadsTextField" destination="sCM-tI-skI" id="D0Z-yT-LbU"/>
                         <outlet property="minWorkIntensityTextField" destination="CuN-wx-fvQ" id="Eik-Z2-7M7"/>
+                        <outlet property="profilingUITestDataMarshalingStatus" destination="2LR-W8-mNE" id="S4k-Yg-EsB"/>
+                        <outlet property="profilingUITestDataMarshalingTextField" destination="5zI-Ix-rMJ" id="2o6-Cc-NMl"/>
                         <outlet property="valueTextField" destination="uTM-T7-Gv6" id="M59-lx-juE"/>
                         <outlet property="workIntensityFactorLabel" destination="cAO-gr-3HC" id="BvB-NZ-TXI"/>
                         <outlet property="workIntervalSlider" destination="N8m-ny-upJ" id="3MU-ZK-5qD"/>
diff --git a/Samples/iOS-Swift/iOS-Swift/Profiling/ProfilingViewController.swift b/Samples/iOS-Swift/iOS-Swift/Profiling/ProfilingViewController.swift
index bf8e2745a50..5634db06804 100644
--- a/Samples/iOS-Swift/iOS-Swift/Profiling/ProfilingViewController.swift
+++ b/Samples/iOS-Swift/iOS-Swift/Profiling/ProfilingViewController.swift
@@ -1,20 +1,23 @@
 import UIKit
 
-@available(iOS 13.0, *)
 class ProfilingViewController: UIViewController, UITextFieldDelegate {
-
+    
     @IBOutlet weak var workThreadLabel: UILabel!
     @IBOutlet weak var workIntensityFactorLabel: UILabel!
-
+    
     @IBOutlet weak var workThreadSlider: UISlider!
     @IBOutlet weak var workIntervalSlider: UISlider!
-
+    
     @IBOutlet weak var maxThreadsTextField: UITextField!
     @IBOutlet weak var minThreadsTextField: UITextField!
     @IBOutlet weak var minWorkIntensityTextField: UITextField!
     @IBOutlet weak var maxWorkIntensityTextField: UITextField!
     @IBOutlet weak var valueTextField: UITextField!
-
+    
+    @IBOutlet weak var launchProfilingMarkerFileCheckButton: UIButton!
+    @IBOutlet weak var profilingUITestDataMarshalingTextField: UITextField!
+    @IBOutlet weak var profilingUITestDataMarshalingStatus: UILabel!
+    
     override func viewDidLoad() {
         super.viewDidLoad()
         minWorkIntensityTextField.text = String(defaultLongestIntervalMicros)
@@ -24,73 +27,134 @@ class ProfilingViewController: UIViewController, UITextFieldDelegate {
         [maxThreadsTextField, minThreadsTextField, minWorkIntensityTextField, maxWorkIntensityTextField].forEach {
             $0?.delegate = self
         }
+        profilingUITestDataMarshalingTextField.accessibilityLabel = "io.sentry.ui-tests.profile-marshaling-text-field"
+        launchProfilingMarkerFileCheckButton.accessibilityLabel = "io.sentry.ui-tests.app-launch-profile-marker-file-button"
     }
     
     override func viewDidAppear(_ animated: Bool) {
         super.viewDidAppear(animated)
         SentrySDK.reportFullyDisplayed()
     }
-
+    
     @IBAction func startBenchmark(_ sender: UIButton) {
         highlightButton(sender)
         SentryBenchmarking.startBenchmark()
     }
-
+    
     @IBAction func stopBenchmark(_ sender: UIButton) {
         highlightButton(sender)
         let value = SentryBenchmarking.stopBenchmark()!
         valueTextField.isHidden = false
         valueTextField.text = value
-        print("[iOS-Swift] benchmarking results:\n\(value)")
+        print("[iOS-Swift] [debug] [ProfilingViewController] benchmarking results:\n\(value)")
     }
-
+    
     @IBAction func startCPUWork(_ sender: UIButton) {
         highlightButton(sender)
         _adjustWorkThreadsToCurrentRequirement()
     }
-
+    
     @IBAction func minWorkThreadCountChanged(_ sender: Any) {
         _adjustWorkThreadsToCurrentRequirement()
     }
-
+    
     @IBAction func workThreadSliderChanged(_ sender: Any) {
         _adjustWorkThreadsToCurrentRequirement()
     }
-
+    
     @IBAction func maxWorkThreadCountChanged(_ sender: Any) {
         _adjustWorkThreadsToCurrentRequirement()
     }
-
+    
     @IBAction func endCPUWork(_ sender: UIButton) {
         highlightButton(sender)
         cpuWorkthreads.forEach { $0.cancel() }
         cpuWorkthreads.removeAll()
     }
-
+    
     @IBAction func minWorkIntervalChanged(_ sender: Any) {
         _adjustWorkIntervalToCurrentRequirements()
     }
-
+    
     @IBAction func workIntensityChanged(_ sender: UISlider) {
         _adjustWorkIntervalToCurrentRequirements()
     }
-
+    
     @IBAction func maxWorkIntervalChanged(_ sender: Any) {
         _adjustWorkIntervalToCurrentRequirements()
     }
-
+    
     @IBAction func bgBrightnessChanged(_ sender: UISlider) {
         view.backgroundColor = .init(white: CGFloat(sender.value), alpha: 1)
     }
-
+    
+    @IBAction func checkLaunchProfilingMarkerFile(_ sender: Any) {
+        let launchProfileMarkerPath = ((NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).first! as NSString).appendingPathComponent("io.sentry") as NSString).appendingPathComponent("profileLaunch")
+        if FileManager.default.fileExists(atPath: launchProfileMarkerPath) {
+            profilingUITestDataMarshalingTextField.text = "<exists>"
+        } else {
+            profilingUITestDataMarshalingTextField.text = "<missing>"
+        }
+    }
+    
+    @IBAction func viewLastProfile(_ sender: Any) {
+        profilingUITestDataMarshalingTextField.text = "<fetching...>"
+        withProfile(fileName: "profile") { file in
+            handleContents(file: file)
+        }
+    }
+    
+    @IBAction func viewLaunchProfile(_ sender: Any) {
+        profilingUITestDataMarshalingTextField.text = "<fetching...>"
+        withProfile(fileName: "launchProfile") { file in
+            handleContents(file: file)
+        }
+    }
+        
     // MARK: UITextFieldDelegate
-
+    
     func textFieldShouldReturn(_ textField: UITextField) -> Bool {
         textField.resignFirstResponder()
     }
+}
 
-    // MARK: Private
-
+// MARK: Private
+extension ProfilingViewController {
+    func withProfile(fileName: String, block: (URL?) -> Void) {
+        let appSupportDirectory = NSSearchPathForDirectoriesInDomains(.applicationSupportDirectory, .userDomainMask, true).first!
+        guard let url = URL(string: appSupportDirectory) else {
+            block(nil)
+            return
+        }
+        for file in FileManager.default.enumerator(at: url, includingPropertiesForKeys: [URLResourceKey.nameKey])! {
+            let url = file as! URL
+            if url.absoluteString.contains(fileName) {
+                block(url)
+                print("[iOS-Swift] [debug] [ProfilingViewController] removing file at \(url)")
+                try! FileManager.default.removeItem(at: url)
+                return
+            }
+        }
+        block(nil)
+    }
+    
+    func handleContents(file: URL?) {
+        guard let file = file else {
+            profilingUITestDataMarshalingTextField.text = "<missing>"
+            profilingUITestDataMarshalingStatus.text = "❌"
+            return
+        }
+        guard let data = try? Data(contentsOf: file) else {
+            profilingUITestDataMarshalingTextField.text = "<empty>"
+            profilingUITestDataMarshalingStatus.text = "❌"
+            return
+        }
+        let contents = data.base64EncodedString()
+        print("[iOS-Swift] [debug] [ProfilingViewController] contents of file at \(file): \(String(describing: String(data: data, encoding: .utf8)))")
+        profilingUITestDataMarshalingTextField.text = contents
+        profilingUITestDataMarshalingStatus.text = "✅"
+    }
+    
     func _adjustWorkThreadsToCurrentRequirement() {
         let maxThreads = (maxThreadsTextField.text! as NSString).integerValue
         let minThreads = (minThreadsTextField.text! as NSString).integerValue
diff --git a/Samples/iOS-Swift/iOS-Swift/TransactionsViewController.swift b/Samples/iOS-Swift/iOS-Swift/TransactionsViewController.swift
index 65d9404966d..9a2cb61fb68 100644
--- a/Samples/iOS-Swift/iOS-Swift/TransactionsViewController.swift
+++ b/Samples/iOS-Swift/iOS-Swift/TransactionsViewController.swift
@@ -61,31 +61,12 @@ class TransactionsViewController: UIViewController {
     }
 
     var spans = [Span]()
-    let profilerNotification = NSNotification.Name("SentryProfileCompleteNotification")
 
     @IBAction func startTransaction(_ sender: UIButton) {
         highlightButton(sender)
         startNewTransaction()
     }
 
-    fileprivate func startNewTransaction() {
-        spans.append(SentrySDK.startTransaction(name: "Manual Transaction", operation: "Manual Operation"))
-
-        NotificationCenter.default.addObserver(forName: profilerNotification, object: nil, queue: nil) { note in
-            DispatchQueue.main.async {
-                let alert = UIAlertController(title: "Profile completed", message: nil, preferredStyle: .alert)
-                alert.addTextField {
-                    //swiftlint:disable force_unwrapping
-                    $0.text = try! JSONSerialization.data(withJSONObject: note.userInfo!).base64EncodedString()
-                    //swiftlint:enable force_unwrapping
-                    $0.accessibilityLabel = "io.sentry.ui-tests.profile-marshaling-text-field"
-                }
-                alert.addAction(UIAlertAction(title: "OK", style: .default))
-                self.present(alert, animated: false)
-            }
-        }
-    }
-
     @IBAction func startTransactionFromOtherThread(_ sender: UIButton) {
         highlightButton(sender)
 
@@ -97,12 +78,6 @@ class TransactionsViewController: UIViewController {
     @IBAction func stopTransaction(_ sender: UIButton) {
         highlightButton(sender)
 
-        defer {
-            if spans.isEmpty {
-                NotificationCenter.default.removeObserver(self, name: profilerNotification, object: nil)
-            }
-        }
-
         func showConfirmation(span: Span) {
             DispatchQueue.main.async {
                 let confirmation = UIAlertController(title: "Finished span \(span.spanId.sentrySpanIdString)", message: nil, preferredStyle: .alert)
@@ -118,6 +93,12 @@ class TransactionsViewController: UIViewController {
             })!)
             showConfirmation(span: span)
         }
+        
+        if spans.isEmpty {
+            if let launchSpan = SentrySDK.span {
+                spans.append(launchSpan)
+            }
+        }
 
         if spans.count == 1 {
             finishSpan(span: spans[0])
@@ -197,3 +178,9 @@ class TransactionsViewController: UIViewController {
         navigationController?.pushViewController(controller, animated: false)
     }
 }
+
+fileprivate extension TransactionsViewController {
+    func startNewTransaction() {
+        spans.append(SentrySDK.startTransaction(name: "Manual Transaction", operation: "Manual Operation"))
+    }
+}
diff --git a/Samples/iOS-Swift/iOS-SwiftUITests/BaseUITest.swift b/Samples/iOS-Swift/iOS-SwiftUITests/BaseUITest.swift
index 94914d37c79..dfdedee18d1 100644
--- a/Samples/iOS-Swift/iOS-SwiftUITests/BaseUITest.swift
+++ b/Samples/iOS-Swift/iOS-SwiftUITests/BaseUITest.swift
@@ -1,26 +1,44 @@
 import XCTest
 
 class BaseUITest: XCTestCase {
-    internal let app: XCUIApplication = XCUIApplication()
+    internal lazy var app: XCUIApplication = newAppSession()
+    
+    //swiftlint:disable implicit_getter
+    var automaticallyLaunchAndTerminateApp: Bool { get { true } }
+    //swiftlint:enable implicit_getter
     
     override func setUp() {
         super.setUp()
         continueAfterFailure = false
         XCUIDevice.shared.orientation = .portrait
-        app.launchEnvironment["io.sentry.ui-test.test-name"] = name
         app.launchEnvironment["io.sentry.sdk-environment"] = "ui-tests"
-        app.launch()
-        
-        waitForExistenceOfMainScreen()
+        if automaticallyLaunchAndTerminateApp {
+            launchApp()
+        }
     }
     
     override func tearDown() {
-        app.terminate()
+        if automaticallyLaunchAndTerminateApp {
+            app.terminate()
+        }
         super.tearDown()
     }
+}
+
+extension BaseUITest {
+    func newAppSession() -> XCUIApplication {
+        let app = XCUIApplication()
+        app.launchEnvironment["io.sentry.ui-test.test-name"] = name
+        return app
+    }
+    
+    func launchApp() {
+        app.launch()
+        waitForExistenceOfMainScreen()
+    }
     
     func waitForExistenceOfMainScreen() {
-        app.waitForExistence( "Home Screen doesn't exist.")
+        app.waitForExistence("Home Screen doesn't exist.")
     }
     
 }
diff --git a/Samples/iOS-Swift/iOS-SwiftUITests/ProfilingUITests.swift b/Samples/iOS-Swift/iOS-SwiftUITests/ProfilingUITests.swift
index 3089f4ab7fd..722ce4cc03b 100644
--- a/Samples/iOS-Swift/iOS-SwiftUITests/ProfilingUITests.swift
+++ b/Samples/iOS-Swift/iOS-SwiftUITests/ProfilingUITests.swift
@@ -1,39 +1,265 @@
 import XCTest
 
-final class ProfilingUITests: BaseUITest {
+//swiftlint:disable function_body_length todo
 
+@available(iOS 16, *)
+class ProfilingUITests: BaseUITest {
+    override var automaticallyLaunchAndTerminateApp: Bool { false }
+    
+    // this will run before the non-async BaseUITest.setUp, so we can bail out before running any of the logic in there
+    override func setUp() async throws {
+        try await super.setUp()
+        try checkEnvironment()
+    }
+    
+    func testProfiledAppLaunches() throws {
+        app.launchArguments.append("--io.sentry.wipe-data")
+        launchApp()
+        
+        // First launch enables in-app profiling by setting traces/profiles sample rates to 1 (which is the default configuration in the sample app), but not launch profiling; assert that we did not write a config to allow the next launch to be profiled.
+        try performAssertions(shouldProfileThisLaunch: false, shouldProfileNextLaunch: false)
+        
+        // no profiling should be done on this launch; set the option to allow launch profiling for the next launch, keeping the default numerical sampling rates of 1 for traces and profiles
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: false, shouldEnableLaunchProfilingOptionForNextLaunch: true)
+        
+        // this launch should run the profiler, then set the option to allow launch profiling to true, but set the numerical sample rates to 0 so that the next launch should not profile
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: true, shouldEnableLaunchProfilingOptionForNextLaunch: true, profilesSampleRate: 0, tracesSampleRate: 0)
+        
+        // this launch should not run the profiler; configure sampler functions returning 1 and numerical rates set to 0, which should result in a profile being taken as samplers override numerical rates
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: false, shouldEnableLaunchProfilingOptionForNextLaunch: true, profilesSampleRate: 0, tracesSampleRate: 0, profilesSamplerValue: 1, tracesSamplerValue: 1)
+        
+        // this launch should run the profiler; configure sampler functions returning 0 and numerical rates set to 0, which should result in no profile being taken next launch
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: true, shouldEnableLaunchProfilingOptionForNextLaunch: true, profilesSamplerValue: 0, tracesSamplerValue: 0)
+        
+        // this launch should not run the profiler, but configure it to run the next launch
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: false, shouldEnableLaunchProfilingOptionForNextLaunch: true)
+        
+        // this launch should run the profiler, and configure it not to run the next launch due to disabling tracing, which would override the option to enable launch profiling
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: true, shouldEnableLaunchProfilingOptionForNextLaunch: true, shouldDisableTracing: true)
+        
+        // make sure the profiler respects the last configuration not to run; don't let another config file get written
+        try relaunchAndConfigureSubsequentLaunches(shouldProfileThisLaunch: false, shouldEnableLaunchProfilingOptionForNextLaunch: false)
+    }
+    
     /**
      * We had a bug where we forgot to install the frames tracker into the profiler, so weren't sending any GPU frame information with profiles. Since it's not possible to enforce such installation via the compiler, we test for the results we expect here, by starting a transaction, triggering an ANR which will cause degraded frame rendering, stop the transaction, and inspect the profile payload.
      */
     func testProfilingGPUInfo() throws {
-        // We don't need to test this on multiple OSes right now, and older versions seem to have issues; older devices or VM images running simulators might just be slower. Latest OS is enough coverage for our needs for now.
-        guard #available(iOS 15.0, *) else {
-           throw XCTSkip("Only run on iOS 15 and above.")
-        }
-
-        app.tabBars["Tab Bar"].buttons["Extra"].tap()
-        app.tabBars["Tab Bar"].buttons["Transactions"].tap()
-        app.buttons["Start transaction (main thread)"].afterWaitingForExistence("Couldn't find button to start transaction").tap()
-
+        app.launchArguments.append("--disable-swizzling") // we're only interested in the manual transaction, the automatic stuff messes up how we try to retrieve the target profile info
+        launchApp()
+        
+        goToTransactions()
+        startTransaction()
+        
         app.buttons["ANR filling run loop"].afterWaitingForExistence("Couldn't find button to ANR").tap()
-        app.buttons["Stop transaction"].afterWaitingForExistence("Couldn't find button to end transaction").tap()
-
-        let textField = app.textFields["io.sentry.ui-tests.profile-marshaling-text-field"]
-        textField.waitForExistence("Couldn't find profile marshaling text field.")
-
-        let profileBase64DataString = try XCTUnwrap(textField.value as? NSString)
-        let profileData = try XCTUnwrap(Data(base64Encoded: profileBase64DataString as String))
-        let profileDict = try XCTUnwrap(try JSONSerialization.jsonObject(with: profileData) as? [String: Any])
-
+        stopTransaction()
+    
+        goToProfiling()
+        retrieveLastProfileData()
+        let profileDict = try marshalJSONDictionaryFromApp()
+        
         let metrics = try XCTUnwrap(profileDict["measurements"] as? [String: Any])
         // We can only be sure about frozen frames when triggering an ANR.
         // It could be that there is no slow frame for the captured transaction.
         let frozenFrames = try XCTUnwrap(metrics["frozen_frame_renders"] as? [String: Any])
         let frozenFrameValues = try XCTUnwrap(frozenFrames["values"] as? [[String: Any]])
         XCTAssertFalse(frozenFrameValues.isEmpty, "The test triggered an ANR while the transaction is running. There must be at least one frozen frame, but there was none.")
-
+        
         let frameRates = try XCTUnwrap(metrics["screen_frame_rates"] as? [String: Any])
         let frameRateValues = try XCTUnwrap(frameRates["values"] as? [[String: Any]])
         XCTAssertFalse(frameRateValues.isEmpty)
     }
 }
+
+@available(iOS 16, *)
+extension ProfilingUITests {
+    // We don't need to test these on multiple OSes right now, and older versions seem to have issues; older devices or VM images running simulators might just be slower. Latest OS is enough coverage for our needs for now.
+    func checkEnvironment() throws {
+#if !targetEnvironment(simulator)
+        throw XCTSkip("Currently doesn't work on SauceLabs.")
+#endif
+
+        guard #available(iOS 16.0, *) else {
+            throw XCTSkip("iOS version too old for profiling test.")
+        }
+    }
+    
+    enum Error: Swift.Error {
+        case missingFile
+        case emptyFile
+    }
+    
+    func marshalJSONDictionaryFromApp() throws -> [String: Any] {
+        let string = try XCTUnwrap(app.textFields["io.sentry.ui-tests.profile-marshaling-text-field"].afterWaitingForExistence("Couldn't find data marshaling text field.").value as? NSString)
+        if string == "<missing>" {
+            throw Error.missingFile
+        }
+        if string == "<empty>" {
+            throw Error.emptyFile
+        }
+        let data = try XCTUnwrap(Data(base64Encoded: string as String))
+        return try XCTUnwrap(try JSONSerialization.jsonObject(with: data) as? [String: Any])
+    }
+    
+    func checkLaunchProfileMarkerFileExistence() throws -> Bool {
+        app.buttons["io.sentry.ui-tests.app-launch-profile-marker-file-button"].afterWaitingForExistence("Couldn't find app launch profile marker file check button").tap()
+        let string = try XCTUnwrap(app.textFields["io.sentry.ui-tests.profile-marshaling-text-field"].afterWaitingForExistence("Couldn't find data marshaling text field.").value as? NSString)
+        return string == "<exists>"
+    }
+    
+    func goToTransactions() {
+        app.tabBars["Tab Bar"].buttons["Transactions"].tap()
+    }
+    
+    func startTransaction() {
+        app.buttons["Start transaction (main thread)"].afterWaitingForExistence("Couldn't find button to start transaction").tap()
+    }
+    
+    func stopTransaction() {
+        app.buttons["Stop transaction"].afterWaitingForExistence("Couldn't find button to end transaction").tap()
+    }
+    
+    func goToProfiling() {
+        app.tabBars["Tab Bar"].buttons["Profiling"].afterWaitingForExistence("Couldn't find profiling tab bar button").tap()
+    }
+    
+    func retrieveLastProfileData() {
+        app.buttons["View last profile"].afterWaitingForExistence("Couldn't find button to view last profile").tap()
+    }
+    
+    func retrieveLaunchProfileData() {
+        app.buttons["View launch profile"].afterWaitingForExistence("Couldn't find button to view launch profile").tap()
+    }
+
+    func assertLaunchProfile() throws {
+        retrieveLaunchProfileData()
+        
+        let lastProfile = try marshalJSONDictionaryFromApp()
+        let sampledProfile = try XCTUnwrap(lastProfile["profile"] as? [String: Any])
+        let stacks = try XCTUnwrap(sampledProfile["stacks"] as? [[Int]])
+        let frames = try XCTUnwrap(sampledProfile["frames"] as? [[String: Any]])
+        let stackFunctions = stacks.map({ stack in
+            stack.map { stackFrame in
+                frames[stackFrame]["function"]
+            }
+        })
+        
+        // grab the first stack that contained frames from the fixture code that simulates a slow +[load] method
+        var stackID: Int?
+        let stack = try XCTUnwrap(stackFunctions.enumerated().first { nextStack in
+            let result = nextStack.element.contains { frame in
+                let result = (frame as! String).contains("+[SentryProfiler(SlowLoad) load]")
+                if result {
+                    stackID = nextStack.offset
+                }
+                return result
+            }
+            return result
+        }).element.map { any in
+            try XCTUnwrap(any as? String)
+        }
+        guard stackID != nil else {
+            XCTFail("Didn't find the ID of the stack containing the target function")
+            return
+        }
+        
+        // ensure that the stack doesn't contain any calls to main functions; this ensures we actually captured pre-main stacks
+        XCTAssertFalse(stack.contains("main"))
+        XCTAssertFalse(stack.contains("UIApplicationMain"))
+        XCTAssertFalse(stack.contains("-[UIApplication _run]"))
+        
+        // ensure that the stack happened on the main thread; this is a cross-check to make sure we didn't accidentally grab a stack from a different thread that wouldn't have had a call to main() anyways, thereby possibly missing the real stack that may have contained main() calls (but shouldn't for this test)
+        let samples = try XCTUnwrap(sampledProfile["samples"] as? [[String: Any]])
+        let sample = try XCTUnwrap(samples.first { nextSample in
+            try XCTUnwrap(nextSample["stack_id"] as? NSNumber).intValue == stackID
+        })
+        XCTAssert(try XCTUnwrap(sample["thread_id"] as? String) == "259") // the main thread is always ID 259
+    }
+     
+    /**
+     * Performs the various operations for the launch profiler test case:
+     * - terminates an existing app session
+     * - creates a new one
+     * - sets launch args and env vars to set the appropriate `SentryOption` values for the desired behavior
+     * - launches the new configured app session
+     * - asserts the expected outcomes of the config file and launch profiler
+     */
+    func relaunchAndConfigureSubsequentLaunches(
+        shouldProfileThisLaunch: Bool,
+        shouldEnableLaunchProfilingOptionForNextLaunch: Bool,
+        profilesSampleRate: Int? = nil,
+        tracesSampleRate: Int? = nil,
+        profilesSamplerValue: Int? = nil,
+        tracesSamplerValue: Int? = nil,
+        shouldDisableAutoPerformanceTracking: Bool = false,
+        shouldDisableUIViewControllerTracing: Bool = false,
+        shouldDisableSwizzling: Bool = false,
+        shouldDisableTracing: Bool = false
+    ) throws {
+        app.terminate()
+        app = newAppSession()
+                
+        if shouldProfileThisLaunch {
+            app.launchArguments.append("--io.sentry.slow-load-method")
+        }
+        if shouldEnableLaunchProfilingOptionForNextLaunch {
+            app.launchArguments.append("--profile-app-launches")
+        }
+        
+        var resolvedProfilesSampleRate: Int?
+        if let profilesSampleRate = profilesSampleRate {
+            app.launchEnvironment["--io.sentry.profilesSampleRate"] = String(profilesSampleRate)
+            resolvedProfilesSampleRate = profilesSampleRate
+        }
+        if let profilesSamplerValue = profilesSamplerValue {
+            app.launchEnvironment["--io.sentry.profilesSamplerValue"] = String(profilesSamplerValue)
+            resolvedProfilesSampleRate = profilesSamplerValue
+        }
+        
+        var resolvedTracesSampleRate: Int?
+        if let tracesSampleRate = tracesSampleRate {
+            app.launchEnvironment["--io.sentry.tracesSampleRate"] = String(tracesSampleRate)
+            resolvedTracesSampleRate = tracesSampleRate
+        }
+        if let tracesSamplerValue = tracesSamplerValue {
+            app.launchEnvironment["--io.sentry.tracesSamplerValue"] = String(tracesSamplerValue)
+            resolvedTracesSampleRate = tracesSamplerValue
+        }
+        
+        if shouldDisableTracing {
+            app.launchArguments.append("--disable-tracing")
+        }
+        if shouldDisableSwizzling {
+            app.launchArguments.append("--disable-swizzling")
+        }
+        if shouldDisableAutoPerformanceTracking {
+            app.launchArguments.append("--disable-auto-performance-tracing")
+        }
+        if shouldDisableUIViewControllerTracing {
+            app.launchArguments.append("--disable-uiviewcontroller-tracing")
+        }
+        
+        launchApp()
+        
+        let sdkOptionsConfigurationAllowsLaunchProfiling = !(shouldDisableTracing || shouldDisableSwizzling || shouldDisableAutoPerformanceTracking || shouldDisableUIViewControllerTracing)
+        
+        // these tests only set sample rates to 0 or 1, or don't provide an override (and the sample app sets them to 1 by default)
+        let sampleRatesAllowLaunchProfiling = (resolvedTracesSampleRate == nil || resolvedTracesSampleRate! == 1) && (resolvedProfilesSampleRate == nil || resolvedProfilesSampleRate == 1)
+        
+        let shouldProfileNextLaunch = shouldEnableLaunchProfilingOptionForNextLaunch && sdkOptionsConfigurationAllowsLaunchProfiling && sampleRatesAllowLaunchProfiling
+        
+        try performAssertions(shouldProfileThisLaunch: shouldProfileThisLaunch, shouldProfileNextLaunch: shouldProfileNextLaunch)
+    }
+    
+    func performAssertions(shouldProfileThisLaunch: Bool, shouldProfileNextLaunch: Bool ) throws {
+        goToProfiling()
+        
+        XCTAssertEqual(shouldProfileNextLaunch, try checkLaunchProfileMarkerFileExistence())
+        
+        if shouldProfileThisLaunch {
+            try assertLaunchProfile()
+        }
+    }
+}
+
+//swiftlint:enable function_body_length todo
diff --git a/Samples/iOS-SwiftUI/iOS-SwiftUI.xcodeproj/project.pbxproj b/Samples/iOS-SwiftUI/iOS-SwiftUI.xcodeproj/project.pbxproj
index bf19ebc12a7..cdcca02809e 100644
--- a/Samples/iOS-SwiftUI/iOS-SwiftUI.xcodeproj/project.pbxproj
+++ b/Samples/iOS-SwiftUI/iOS-SwiftUI.xcodeproj/project.pbxproj
@@ -44,6 +44,62 @@
 			remoteGlobalIDString = 7BB6224826A56C4E00D0E75E;
 			remoteInfo = "iOS-SwiftUI";
 		};
+		8425DE222B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEA828ECD52700EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8431EFD929B27B1100D8DC56;
+			remoteInfo = SentryProfilerTests;
+		};
+		8425DE242B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEA828ECD52700EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8431F00A29B284F200D8DC56;
+			remoteInfo = SentryTestUtils;
+		};
+		8425DE262B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEA828ECD52700EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D84DAD4D2B17428D003CF120;
+			remoteInfo = SentryTestUtilsDynamic;
+		};
+		8425DE2F2B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D81A3488291D0AC0005A27A9;
+			remoteInfo = SentryPrivate;
+		};
+		8425DE312B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D8199DAA29376E9B0074249E;
+			remoteInfo = SentrySwiftUI;
+		};
+		8425DE332B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8431EFD929B27B1100D8DC56;
+			remoteInfo = SentryProfilerTests;
+		};
+		8425DE352B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8431F00A29B284F200D8DC56;
+			remoteInfo = SentryTestUtils;
+		};
+		8425DE372B52241000113FEF /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = D84DAD4D2B17428D003CF120;
+			remoteInfo = SentryTestUtilsDynamic;
+		};
 		84D4FEB128ECD52E00EDAAFE /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */;
@@ -103,6 +159,7 @@
 		7BB6225526A56C5000D0E75E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		7BB6225C26A56CB600D0E75E /* Sentry.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = Sentry.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		7BB6226026A56E1E00D0E75E /* iOS-SwiftUI.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = "iOS-SwiftUI.entitlements"; sourceTree = "<group>"; };
+		8425DE1A2B52241000113FEF /* SentryProfilingConditionals.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryProfilingConditionals.h; path = ../../../../Sources/Sentry/Public/SentryProfilingConditionals.h; sourceTree = "<group>"; };
 		84D4FEA628ECD51800EDAAFE /* Sentry.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = Sentry.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		84D4FEA828ECD52700EDAAFE /* Sentry.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = Sentry.xcodeproj; path = ../../Sentry.xcodeproj; sourceTree = "<group>"; };
 		84D4FEAA28ECD52E00EDAAFE /* Sentry.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = Sentry.xcodeproj; path = "/Users/andrewmcknight/Code/organization/getsentry/repos/public/sentry-cocoa/Sentry.xcodeproj"; sourceTree = "<absolute>"; };
@@ -143,6 +200,9 @@
 				0A94158028F6B893006A5DD1 /* SentryTests.xctest */,
 				D8199DCC29376FD30074249E /* SentryPrivate.framework */,
 				D8BBD38B2901AE400011F850 /* SentrySwiftUI.framework */,
+				8425DE232B52241000113FEF /* SentryProfilerTests.xctest */,
+				8425DE252B52241000113FEF /* libSentryTestUtils.a */,
+				8425DE272B52241000113FEF /* SentryTestUtilsDynamic.framework */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -218,6 +278,11 @@
 			children = (
 				84D4FEB228ECD52E00EDAAFE /* Sentry.framework */,
 				84D4FEB428ECD52E00EDAAFE /* SentryTests.xctest */,
+				8425DE302B52241000113FEF /* SentryPrivate.framework */,
+				8425DE322B52241000113FEF /* SentrySwiftUI.framework */,
+				8425DE342B52241000113FEF /* SentryProfilerTests.xctest */,
+				8425DE362B52241000113FEF /* libSentryTestUtils.a */,
+				8425DE382B52241000113FEF /* SentryTestUtilsDynamic.framework */,
 			);
 			name = Products;
 			sourceTree = "<group>";
@@ -226,6 +291,7 @@
 			isa = PBXGroup;
 			children = (
 				D8A22A7E2915238A006907D9 /* SentryPerformanceTracker.h */,
+				8425DE1A2B52241000113FEF /* SentryProfilingConditionals.h */,
 				D8A22A7D2915238A006907D9 /* SentryTracer.h */,
 				D8A22A7829151E26006907D9 /* SentrySpanProtocol.h */,
 				D8A22A7A291522EE006907D9 /* SentryDefines.h */,
@@ -335,6 +401,62 @@
 			remoteRef = 0A94157F28F6B893006A5DD1 /* PBXContainerItemProxy */;
 			sourceTree = BUILT_PRODUCTS_DIR;
 		};
+		8425DE232B52241000113FEF /* SentryProfilerTests.xctest */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = SentryProfilerTests.xctest;
+			remoteRef = 8425DE222B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE252B52241000113FEF /* libSentryTestUtils.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libSentryTestUtils.a;
+			remoteRef = 8425DE242B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE272B52241000113FEF /* SentryTestUtilsDynamic.framework */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.framework;
+			path = SentryTestUtilsDynamic.framework;
+			remoteRef = 8425DE262B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE302B52241000113FEF /* SentryPrivate.framework */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.framework;
+			path = SentryPrivate.framework;
+			remoteRef = 8425DE2F2B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE322B52241000113FEF /* SentrySwiftUI.framework */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.framework;
+			path = SentrySwiftUI.framework;
+			remoteRef = 8425DE312B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE342B52241000113FEF /* SentryProfilerTests.xctest */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = SentryProfilerTests.xctest;
+			remoteRef = 8425DE332B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE362B52241000113FEF /* libSentryTestUtils.a */ = {
+			isa = PBXReferenceProxy;
+			fileType = archive.ar;
+			path = libSentryTestUtils.a;
+			remoteRef = 8425DE352B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		8425DE382B52241000113FEF /* SentryTestUtilsDynamic.framework */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.framework;
+			path = SentryTestUtilsDynamic.framework;
+			remoteRef = 8425DE372B52241000113FEF /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
 		84D4FEB228ECD52E00EDAAFE /* Sentry.framework */ = {
 			isa = PBXReferenceProxy;
 			fileType = wrapper.framework;
diff --git a/Sentry.xcodeproj/project.pbxproj b/Sentry.xcodeproj/project.pbxproj
index 4fa5d95953f..0365bc7dbd8 100644
--- a/Sentry.xcodeproj/project.pbxproj
+++ b/Sentry.xcodeproj/project.pbxproj
@@ -8,8 +8,6 @@
 
 /* Begin PBXBuildFile section */
 		0354A22B2A134D9C003C3A04 /* SentryProfilerState.h in Headers */ = {isa = PBXBuildFile; fileRef = 0354A22A2A134D9C003C3A04 /* SentryProfilerState.h */; };
-		0356A570288B4612008BF593 /* SentryProfilesSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 0356A56E288B4612008BF593 /* SentryProfilesSampler.h */; };
-		0356A571288B4612008BF593 /* SentryProfilesSampler.m in Sources */ = {isa = PBXBuildFile; fileRef = 0356A56F288B4612008BF593 /* SentryProfilesSampler.m */; };
 		03BCC38A27E1BF49003232C7 /* SentryTime.h in Headers */ = {isa = PBXBuildFile; fileRef = 03BCC38927E1BF49003232C7 /* SentryTime.h */; };
 		03BCC38C27E1C01A003232C7 /* SentryTime.mm in Sources */ = {isa = PBXBuildFile; fileRef = 03BCC38B27E1C01A003232C7 /* SentryTime.mm */; };
 		03BCC38E27E2A377003232C7 /* SentryProfilingConditionals.h in Headers */ = {isa = PBXBuildFile; fileRef = 03BCC38D27E2A377003232C7 /* SentryProfilingConditionals.h */; settings = {ATTRIBUTES = (Public, ); }; };
@@ -608,11 +606,14 @@
 		7DC83100239826280043DD9A /* SentryIntegrationProtocol.h in Headers */ = {isa = PBXBuildFile; fileRef = 7DC830FF239826280043DD9A /* SentryIntegrationProtocol.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		7DC8310A2398283C0043DD9A /* SentryCrashIntegration.h in Headers */ = {isa = PBXBuildFile; fileRef = 7DC831082398283C0043DD9A /* SentryCrashIntegration.h */; };
 		7DC8310C2398283C0043DD9A /* SentryCrashIntegration.m in Sources */ = {isa = PBXBuildFile; fileRef = 7DC831092398283C0043DD9A /* SentryCrashIntegration.m */; };
+		840A11122B61E27500650D02 /* SentrySamplerDecision.m in Sources */ = {isa = PBXBuildFile; fileRef = 840A11102B61E27500650D02 /* SentrySamplerDecision.m */; };
+		840A11132B61FE5800650D02 /* SentryAppLaunchProfilingTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 840A11092B5F47F700650D02 /* SentryAppLaunchProfilingTests.m */; };
 		84281C432A578E5600EE88F2 /* SentryProfilerState.mm in Sources */ = {isa = PBXBuildFile; fileRef = 84281C422A578E5600EE88F2 /* SentryProfilerState.mm */; };
 		84281C462A57905700EE88F2 /* SentrySample.h in Headers */ = {isa = PBXBuildFile; fileRef = 84281C442A57905700EE88F2 /* SentrySample.h */; };
 		84281C472A57905700EE88F2 /* SentrySample.m in Sources */ = {isa = PBXBuildFile; fileRef = 84281C452A57905700EE88F2 /* SentrySample.m */; };
 		84281C622A579D0700EE88F2 /* SentryProfilerMocksSwiftCompatible.mm in Sources */ = {isa = PBXBuildFile; fileRef = 84281C4D2A579A0C00EE88F2 /* SentryProfilerMocksSwiftCompatible.mm */; };
 		84281C632A579D0700EE88F2 /* SentryProfilerMocks.mm in Sources */ = {isa = PBXBuildFile; fileRef = 84281C492A57933600EE88F2 /* SentryProfilerMocks.mm */; };
+		84302A812B5767A50027A629 /* SentryLaunchProfiling.m in Sources */ = {isa = PBXBuildFile; fileRef = 84302A7F2B5767A50027A629 /* SentryLaunchProfiling.m */; };
 		8431EE5B29ADB8EA00D8DC56 /* SentryTimeTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 8431EE5A29ADB8EA00D8DC56 /* SentryTimeTests.m */; };
 		8431EFD129B27B1100D8DC56 /* Sentry.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 63AA759B1EB8AEF500D153DE /* Sentry.framework */; settings = {ATTRIBUTES = (Required, ); }; };
 		8431EFD329B27B1100D8DC56 /* Resources in Resources */ = {isa = PBXBuildFile; fileRef = 630C01951EC341D600C52CEF /* Resources */; };
@@ -625,7 +626,6 @@
 		8431EFE229B27BAD00D8DC56 /* SentryNSTimerFactoryTest.swift in Sources */ = {isa = PBXBuildFile; fileRef = 849472842971C41A002603DE /* SentryNSTimerFactoryTest.swift */; };
 		8431EFE529B27BAD00D8DC56 /* SentryNSProcessInfoWrapperTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 849472822971C2CD002603DE /* SentryNSProcessInfoWrapperTests.swift */; };
 		8431EFE829B27BAD00D8DC56 /* SentrySystemWrapperTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 849472802971C107002603DE /* SentrySystemWrapperTests.swift */; };
-		8431F00529B2849A00D8DC56 /* (null) in Sources */ = {isa = PBXBuildFile; };
 		8431F01529B2851500D8DC56 /* TestSentryNSTimerFactory.swift in Sources */ = {isa = PBXBuildFile; fileRef = 844EDCE72947DCD700C86F34 /* TestSentryNSTimerFactory.swift */; };
 		8431F01629B2851500D8DC56 /* TestSentryNSProcessInfoWrapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 844EDC712941442200C86F34 /* TestSentryNSProcessInfoWrapper.swift */; };
 		8431F01729B2851500D8DC56 /* TestSentrySystemWrapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 844EDC7829415AB300C86F34 /* TestSentrySystemWrapper.swift */; };
@@ -675,6 +675,8 @@
 		84B7FA4429B2924000AD93B1 /* TestRandom.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8E25C97425F8511A00DC215B /* TestRandom.swift */; };
 		84B7FA4529B2926900AD93B1 /* TestDisplayLinkWrapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7B30B68126527C55006B2752 /* TestDisplayLinkWrapper.swift */; };
 		84B7FA4629B2935F00AD93B1 /* ClearTestState.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7BD47B4C268F0B080076A663 /* ClearTestState.swift */; };
+		84DEE86B2B686BD400A7BC17 /* SentrySamplerDecision.h in Headers */ = {isa = PBXBuildFile; fileRef = 84DEE86A2B686BD400A7BC17 /* SentrySamplerDecision.h */; };
+		84DEE8762B69AD6400A7BC17 /* SentryLaunchProfiling.h in Headers */ = {isa = PBXBuildFile; fileRef = 84DEE8752B69AD6400A7BC17 /* SentryLaunchProfiling.h */; };
 		84F993C42A62A74000EC0190 /* SentryCurrentDateProvider.m in Sources */ = {isa = PBXBuildFile; fileRef = 84F993C32A62A74000EC0190 /* SentryCurrentDateProvider.m */; };
 		84F994E62A6894B500EC0190 /* CoreData.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 84F994E52A6894B500EC0190 /* CoreData.framework */; };
 		84F994E82A6894BD00EC0190 /* SystemConfiguration.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 84F994E72A6894BD00EC0190 /* SystemConfiguration.framework */; platformFilters = (ios, maccatalyst, macos, tvos, ); };
@@ -701,8 +703,8 @@
 		8E70B10125CB8695002B3155 /* SentrySpanIdTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8E70B10025CB8695002B3155 /* SentrySpanIdTests.swift */; };
 		8E7C982F2693D56000E6336C /* SentryTraceHeader.m in Sources */ = {isa = PBXBuildFile; fileRef = 8E7C982D2693D56000E6336C /* SentryTraceHeader.m */; };
 		8E7C98312693E1CC00E6336C /* SentryTraceHeader.h in Headers */ = {isa = PBXBuildFile; fileRef = 8E7C98302693E1CC00E6336C /* SentryTraceHeader.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		8E8C57A225EEFC07001CEEFA /* SentryTracesSampler.m in Sources */ = {isa = PBXBuildFile; fileRef = 8E8C57A025EEFC07001CEEFA /* SentryTracesSampler.m */; };
-		8E8C57A625EEFC43001CEEFA /* SentryTracesSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 8E8C57A525EEFC42001CEEFA /* SentryTracesSampler.h */; };
+		8E8C57A225EEFC07001CEEFA /* SentrySampling.m in Sources */ = {isa = PBXBuildFile; fileRef = 8E8C57A025EEFC07001CEEFA /* SentrySampling.m */; };
+		8E8C57A625EEFC43001CEEFA /* SentrySampling.h in Headers */ = {isa = PBXBuildFile; fileRef = 8E8C57A525EEFC42001CEEFA /* SentrySampling.h */; };
 		8EA05EED267C2AB200C82B30 /* SentryNetworkTrackerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8EA05EEC267C2AB200C82B30 /* SentryNetworkTrackerTests.swift */; };
 		8EA1ED0B2668F8C400E62B98 /* SentryUIViewControllerSwizzling.m in Sources */ = {isa = PBXBuildFile; fileRef = 8EA1ED092668F8C400E62B98 /* SentryUIViewControllerSwizzling.m */; };
 		8EA1ED0D2669028C00E62B98 /* SentryUIViewControllerSwizzling.h in Headers */ = {isa = PBXBuildFile; fileRef = 8EA1ED0C2669028C00E62B98 /* SentryUIViewControllerSwizzling.h */; };
@@ -920,8 +922,6 @@
 
 /* Begin PBXFileReference section */
 		0354A22A2A134D9C003C3A04 /* SentryProfilerState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryProfilerState.h; path = Sources/Sentry/include/SentryProfilerState.h; sourceTree = SOURCE_ROOT; };
-		0356A56E288B4612008BF593 /* SentryProfilesSampler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryProfilesSampler.h; path = Sources/Sentry/include/SentryProfilesSampler.h; sourceTree = SOURCE_ROOT; };
-		0356A56F288B4612008BF593 /* SentryProfilesSampler.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = SentryProfilesSampler.m; path = Sources/Sentry/SentryProfilesSampler.m; sourceTree = SOURCE_ROOT; };
 		035E73C727D56757005EEB11 /* SentryBacktraceTests.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SentryBacktraceTests.mm; sourceTree = "<group>"; };
 		035E73C927D57398005EEB11 /* SentryThreadHandleTests.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SentryThreadHandleTests.mm; sourceTree = "<group>"; };
 		035E73CB27D575B3005EEB11 /* SentrySamplingProfilerTests.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SentrySamplingProfilerTests.mm; sourceTree = "<group>"; };
@@ -1277,7 +1277,7 @@
 		7B42C47F27E08F33009B58C2 /* SentryDependencyContainer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryDependencyContainer.h; path = include/HybridPublic/SentryDependencyContainer.h; sourceTree = "<group>"; };
 		7B42C48127E08F4B009B58C2 /* SentryDependencyContainer.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryDependencyContainer.m; sourceTree = "<group>"; };
 		7B451483263ABAB7008AFFEB /* SentryDebugImageProvider+TestInit.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryDebugImageProvider+TestInit.h"; sourceTree = "<group>"; };
-		7B4C817124D1BC2B0076ACE4 /* SentryFileManager+TestProperties.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryFileManager+TestProperties.h"; sourceTree = "<group>"; };
+		7B4C817124D1BC2B0076ACE4 /* SentryFileManager+Test.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryFileManager+Test.h"; sourceTree = "<group>"; };
 		7B4D308926FC616B00C94DE9 /* SentryHttpTransportTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryHttpTransportTests.swift; sourceTree = "<group>"; };
 		7B4E23AE2519E13800060D68 /* SentryCrashIntegration+TestInit.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryCrashIntegration+TestInit.h"; sourceTree = "<group>"; };
 		7B4E23B5251A07BD00060D68 /* SentryDispatchQueueWrapperTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryDispatchQueueWrapperTests.swift; sourceTree = "<group>"; };
@@ -1573,6 +1573,9 @@
 		7DC830FF239826280043DD9A /* SentryIntegrationProtocol.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryIntegrationProtocol.h; path = Public/SentryIntegrationProtocol.h; sourceTree = "<group>"; };
 		7DC831082398283C0043DD9A /* SentryCrashIntegration.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryCrashIntegration.h; path = include/SentryCrashIntegration.h; sourceTree = "<group>"; };
 		7DC831092398283C0043DD9A /* SentryCrashIntegration.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryCrashIntegration.m; sourceTree = "<group>"; };
+		840A11092B5F47F700650D02 /* SentryAppLaunchProfilingTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryAppLaunchProfilingTests.m; sourceTree = "<group>"; };
+		840A11102B61E27500650D02 /* SentrySamplerDecision.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentrySamplerDecision.m; sourceTree = "<group>"; };
+		840A11142B62041600650D02 /* SentryLaunchProfiling+Tests.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryLaunchProfiling+Tests.h"; sourceTree = "<group>"; };
 		8419C0C328C1889D001C8259 /* SentryProfilerSwiftTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryProfilerSwiftTests.swift; sourceTree = "<group>"; };
 		84281C422A578E5600EE88F2 /* SentryProfilerState.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SentryProfilerState.mm; sourceTree = "<group>"; };
 		84281C442A57905700EE88F2 /* SentrySample.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentrySample.h; path = ../include/SentrySample.h; sourceTree = "<group>"; };
@@ -1583,6 +1586,7 @@
 		84281C4D2A579A0C00EE88F2 /* SentryProfilerMocksSwiftCompatible.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SentryProfilerMocksSwiftCompatible.mm; sourceTree = "<group>"; };
 		84281C642A57D36100EE88F2 /* SentryProfilerState+ObjCpp.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "SentryProfilerState+ObjCpp.h"; path = "../include/SentryProfilerState+ObjCpp.h"; sourceTree = "<group>"; };
 		84281C652A58A16500EE88F2 /* SentryProfiler+Test.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryProfiler+Test.h"; sourceTree = "<group>"; };
+		84302A7F2B5767A50027A629 /* SentryLaunchProfiling.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryLaunchProfiling.m; sourceTree = "<group>"; };
 		8431EE5A29ADB8EA00D8DC56 /* SentryTimeTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTimeTests.m; sourceTree = "<group>"; };
 		8431EFD929B27B1100D8DC56 /* SentryProfilerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SentryProfilerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
 		8431F00A29B284F200D8DC56 /* libSentryTestUtils.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libSentryTestUtils.a; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -1646,6 +1650,8 @@
 		84B7FA3B29B2866200AD93B1 /* SentryTestUtils-ObjC-BridgingHeader.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "SentryTestUtils-ObjC-BridgingHeader.h"; sourceTree = "<group>"; };
 		84B7FA4729B2995A00AD93B1 /* DeploymentTargets.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = DeploymentTargets.xcconfig; sourceTree = "<group>"; };
 		84C47B2B2A09239100DAEB8A /* .codecov.yml */ = {isa = PBXFileReference; lastKnownFileType = text.yaml; path = .codecov.yml; sourceTree = "<group>"; };
+		84DEE86A2B686BD400A7BC17 /* SentrySamplerDecision.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentrySamplerDecision.h; path = include/SentrySamplerDecision.h; sourceTree = "<group>"; };
+		84DEE8752B69AD6400A7BC17 /* SentryLaunchProfiling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryLaunchProfiling.h; path = Sources/Sentry/include/SentryLaunchProfiling.h; sourceTree = SOURCE_ROOT; };
 		84E4F5692914F020004C7358 /* Brewfile */ = {isa = PBXFileReference; indentWidth = 2; lastKnownFileType = text; path = Brewfile; sourceTree = "<group>"; tabWidth = 2; };
 		84F993C32A62A74000EC0190 /* SentryCurrentDateProvider.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryCurrentDateProvider.m; sourceTree = "<group>"; };
 		84F994E52A6894B500EC0190 /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = Platforms/MacOSX.platform/Developer/SDKs/MacOSX13.3.sdk/System/Library/Frameworks/CoreData.framework; sourceTree = DEVELOPER_DIR; };
@@ -1678,8 +1684,8 @@
 		8E70B10025CB8695002B3155 /* SentrySpanIdTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentrySpanIdTests.swift; sourceTree = "<group>"; };
 		8E7C982D2693D56000E6336C /* SentryTraceHeader.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTraceHeader.m; sourceTree = "<group>"; };
 		8E7C98302693E1CC00E6336C /* SentryTraceHeader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryTraceHeader.h; path = Public/SentryTraceHeader.h; sourceTree = "<group>"; };
-		8E8C57A025EEFC07001CEEFA /* SentryTracesSampler.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTracesSampler.m; sourceTree = "<group>"; };
-		8E8C57A525EEFC42001CEEFA /* SentryTracesSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryTracesSampler.h; path = include/SentryTracesSampler.h; sourceTree = "<group>"; };
+		8E8C57A025EEFC07001CEEFA /* SentrySampling.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentrySampling.m; sourceTree = "<group>"; };
+		8E8C57A525EEFC42001CEEFA /* SentrySampling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentrySampling.h; path = include/SentrySampling.h; sourceTree = "<group>"; };
 		8EA05EEC267C2AB200C82B30 /* SentryNetworkTrackerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryNetworkTrackerTests.swift; sourceTree = "<group>"; };
 		8EA1ED092668F8C400E62B98 /* SentryUIViewControllerSwizzling.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryUIViewControllerSwizzling.m; sourceTree = "<group>"; };
 		8EA1ED0C2669028C00E62B98 /* SentryUIViewControllerSwizzling.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryUIViewControllerSwizzling.h; path = include/SentryUIViewControllerSwizzling.h; sourceTree = "<group>"; };
@@ -2294,6 +2300,7 @@
 				7B569DFE2590EEF600B653FC /* SentryScope+Equality.h */,
 				7B569E052590F04700B653FC /* SentryScope+Properties.h */,
 				7B9421C4260CA393001F9349 /* SentrySDK+Tests.h */,
+				840A11142B62041600650D02 /* SentryLaunchProfiling+Tests.h */,
 				639889D21EDF06C100EA7442 /* SentryTests-Bridging-Header.h */,
 				63B819131EC352A7002FDF4C /* SentryInterfacesTests.m */,
 				630C01931EC3402C00C52CEF /* SentryKSCrashReportConverterTests.m */,
@@ -2851,7 +2858,7 @@
 				7BE3C7742445C82300A38442 /* SentryCurrentDateTests.swift */,
 				7BD729992463EA4A00EA3610 /* SentryDateUtilTests.swift */,
 				7B85BD8D24C5C3A6000A4225 /* SentryFileManagerTestExtension.swift */,
-				7B4C817124D1BC2B0076ACE4 /* SentryFileManager+TestProperties.h */,
+				7B4C817124D1BC2B0076ACE4 /* SentryFileManager+Test.h */,
 				7B98D7EB25FB7C4900C5A389 /* SentryAppStateTests.swift */,
 				0A94158128F6C4C2006A5DD1 /* SentryAppStateManagerTests.swift */,
 				69BEE6F62620729E006DF9DF /* UrlSessionDelegateSpy.swift */,
@@ -3193,8 +3200,6 @@
 				0354A22A2A134D9C003C3A04 /* SentryProfilerState.h */,
 				84281C422A578E5600EE88F2 /* SentryProfilerState.mm */,
 				84281C642A57D36100EE88F2 /* SentryProfilerState+ObjCpp.h */,
-				0356A56E288B4612008BF593 /* SentryProfilesSampler.h */,
-				0356A56F288B4612008BF593 /* SentryProfilesSampler.m */,
 				84354E0F29BF944900CDBB8B /* SentryProfileTimeseries.h */,
 				84354E1029BF944900CDBB8B /* SentryProfileTimeseries.mm */,
 				03BCC38D27E2A377003232C7 /* SentryProfilingConditionals.h */,
@@ -3213,6 +3218,8 @@
 				03F84D1927DD414C008FE43F /* SentryThreadState.hpp */,
 				03BCC38927E1BF49003232C7 /* SentryTime.h */,
 				03BCC38B27E1C01A003232C7 /* SentryTime.mm */,
+				84DEE8752B69AD6400A7BC17 /* SentryLaunchProfiling.h */,
+				84302A7F2B5767A50027A629 /* SentryLaunchProfiling.m */,
 			);
 			path = Profiling;
 			sourceTree = "<group>";
@@ -3235,6 +3242,7 @@
 				035E73CB27D575B3005EEB11 /* SentrySamplingProfilerTests.mm */,
 				035E73CD27D5790A005EEB11 /* SentryThreadMetadataCacheTests.mm */,
 				03F9D37B2819A65C00602916 /* SentryProfilerTests.mm */,
+				840A11092B5F47F700650D02 /* SentryAppLaunchProfilingTests.m */,
 				8419C0C328C1889D001C8259 /* SentryProfilerSwiftTests.swift */,
 			);
 			path = SentryProfilerTests;
@@ -3327,8 +3335,10 @@
 				845C16D42A622A5B00EC9519 /* SentryTracer+Private.h */,
 				D8B088B429C9E3FF00213258 /* SentryTracerConfiguration.h */,
 				D8B088B529C9E3FF00213258 /* SentryTracerConfiguration.m */,
-				8E8C57A525EEFC42001CEEFA /* SentryTracesSampler.h */,
-				8E8C57A025EEFC07001CEEFA /* SentryTracesSampler.m */,
+				84DEE86A2B686BD400A7BC17 /* SentrySamplerDecision.h */,
+				840A11102B61E27500650D02 /* SentrySamplerDecision.m */,
+				8E8C57A525EEFC42001CEEFA /* SentrySampling.h */,
+				8E8C57A025EEFC07001CEEFA /* SentrySampling.m */,
 				620379DA2AFE1415005AC0C1 /* SentryBuildAppStartSpans.h */,
 				620379DC2AFE1432005AC0C1 /* SentryBuildAppStartSpans.m */,
 				8E4A037725F6F52100000D77 /* SentrySampleDecision.h */,
@@ -3537,6 +3547,7 @@
 				63FE70F120DA4C1000CDBAE8 /* SentryCrashMonitorType.h in Headers */,
 				7BA0C04628055F8E003E0326 /* SentryTransportAdapter.h in Headers */,
 				63FE717720DA4C1100CDBAE8 /* SentryCrashReportWriter.h in Headers */,
+				84DEE86B2B686BD400A7BC17 /* SentrySamplerDecision.h in Headers */,
 				7B4E23BE251A2BD500060D68 /* SentrySessionCrashedHandler.h in Headers */,
 				7B88F2FE24BC5A4C00ADF90A /* SentrySdkInfo.h in Headers */,
 				7BCFBD672681C95000BC27D8 /* SentryScopeObserver.h in Headers */,
@@ -3594,7 +3605,6 @@
 				84A888FD28D9B11700C51DFD /* SentryProfiler+Private.h in Headers */,
 				7D0637032382B34300B30749 /* SentryScope.h in Headers */,
 				03F84D2727DD414C008FE43F /* SentryMachLogging.hpp in Headers */,
-				0356A570288B4612008BF593 /* SentryProfilesSampler.h in Headers */,
 				63295AF51EF3C7DB002D4490 /* NSDictionary+SentrySanitize.h in Headers */,
 				8E4A037825F6F52100000D77 /* SentrySampleDecision.h in Headers */,
 				63FE717920DA4C1100CDBAE8 /* SentryCrashReportStore.h in Headers */,
@@ -3635,6 +3645,7 @@
 				63FE711F20DA4C1000CDBAE8 /* SentryCrashObjC.h in Headers */,
 				7BC3936825B1AB3E004F03D3 /* SentryLevelMapper.h in Headers */,
 				8E4E7C6E25DAAAFE006AB9E2 /* SentrySpan.h in Headers */,
+				84DEE8762B69AD6400A7BC17 /* SentryLaunchProfiling.h in Headers */,
 				D8ACE3CE2762187D00F5A213 /* SentryNSDataTracker.h in Headers */,
 				03F84D2427DD414C008FE43F /* SentryCompiler.h in Headers */,
 				631E6D331EBC679C00712345 /* SentryQueueableRequestManager.h in Headers */,
@@ -3752,7 +3763,7 @@
 				63FE716F20DA4C1100CDBAE8 /* SentryCrashCPU_Apple.h in Headers */,
 				639FCFA81EBC80CC00778193 /* SentryFrame.h in Headers */,
 				D8BFE37229A3782F002E73F3 /* SentryTimeToDisplayTracker.h in Headers */,
-				8E8C57A625EEFC43001CEEFA /* SentryTracesSampler.h in Headers */,
+				8E8C57A625EEFC43001CEEFA /* SentrySampling.h in Headers */,
 				7B634599280EB9D100CFA05A /* SentryUIEventTrackingIntegration.h in Headers */,
 				63FE716D20DA4C1100CDBAE8 /* SentryCrashSysCtl.h in Headers */,
 				639889BB1EDED18400EA7442 /* SentrySwizzle.h in Headers */,
@@ -4122,6 +4133,7 @@
 				7B6C5EDE264E8DF00010D138 /* SentryFramesTracker.m in Sources */,
 				D84F833E2A1CC401005828E0 /* SentrySwiftAsyncIntegration.m in Sources */,
 				7B6438AB26A70F24000D0F65 /* UIViewController+Sentry.m in Sources */,
+				84302A812B5767A50027A629 /* SentryLaunchProfiling.m in Sources */,
 				63AA76A31EB9CBAA00D153DE /* SentryDsn.m in Sources */,
 				63B818FA1EC34639002FDF4C /* SentryDebugMeta.m in Sources */,
 				7B98D7D325FB65AE00C5A389 /* SentryWatchdogTerminationTracker.m in Sources */,
@@ -4210,6 +4222,7 @@
 				0A9BF4E228A114940068D266 /* SentryViewHierarchyIntegration.m in Sources */,
 				0ADC33EC28D9BB780078D980 /* SentryUIDeviceWrapper.m in Sources */,
 				7BBD188B244841FB00427C76 /* SentryHttpDateParser.m in Sources */,
+				840A11122B61E27500650D02 /* SentrySamplerDecision.m in Sources */,
 				8E4E7C8225DAB2A5006AB9E2 /* SentryTracer.m in Sources */,
 				15E0A8E5240C457D00F044E3 /* SentryEnvelope.m in Sources */,
 				03F84D3627DD4191008FE43F /* SentryProfilingLogging.mm in Sources */,
@@ -4278,7 +4291,7 @@
 				7BBD18932449BEDD00427C76 /* SentryDefaultRateLimits.m in Sources */,
 				7BD729982463E93500EA3610 /* SentryDateUtil.m in Sources */,
 				639FCF9D1EBC7F9500778193 /* SentryThread.m in Sources */,
-				8E8C57A225EEFC07001CEEFA /* SentryTracesSampler.m in Sources */,
+				8E8C57A225EEFC07001CEEFA /* SentrySampling.m in Sources */,
 				8454CF8D293EAF9A006AC140 /* SentryMetricProfiler.mm in Sources */,
 				63FE714120DA4C1100CDBAE8 /* SentryCrashDate.c in Sources */,
 				63FE70DB20DA4C1000CDBAE8 /* SentryCrashMonitor_System.m in Sources */,
@@ -4327,7 +4340,6 @@
 				D85852BA27EDDC5900C6D8AE /* SentryUIApplication.m in Sources */,
 				7B4E375F258231FC00059C93 /* SentryAttachment.m in Sources */,
 				636085141ED47BE600E8599E /* SentryFileManager.m in Sources */,
-				0356A571288B4612008BF593 /* SentryProfilesSampler.m in Sources */,
 				63FE710B20DA4C1000CDBAE8 /* SentryCrashMach.c in Sources */,
 				63FE707720DA4C1000CDBAE8 /* Container+SentryDeepSearch.m in Sources */,
 				7BC9A20628F41781001E7C4C /* SentryMeasurementUnit.m in Sources */,
@@ -4506,7 +4518,6 @@
 				0A2D7BBA29152CBF008727AF /* SentryWatchdogTerminationsScopeObserverTests.swift in Sources */,
 				7BD4BD4B27EB2DC20071F4FF /* SentryDiscardedEventTests.swift in Sources */,
 				63FE721A20DA66EC00CDBAE8 /* SentryCrashSysCtl_Tests.m in Sources */,
-				8431F00529B2849A00D8DC56 /* (null) in Sources */,
 				7B88F30424BC8E6500ADF90A /* SentrySerializationTests.swift in Sources */,
 				7B34721728086A9D0041F047 /* SentrySwizzleWrapperTests.swift in Sources */,
 				8EC4CF5025C3A0070093DEE9 /* SentrySpanContextTests.swift in Sources */,
@@ -4602,6 +4613,7 @@
 				8431EFE129B27B5300D8DC56 /* SentryThreadMetadataCacheTests.mm in Sources */,
 				8431EFE029B27B5300D8DC56 /* SentryBacktraceTests.mm in Sources */,
 				8431EFDF29B27B5300D8DC56 /* SentryThreadHandleTests.mm in Sources */,
+				840A11132B61FE5800650D02 /* SentryAppLaunchProfilingTests.m in Sources */,
 				8431EFE829B27BAD00D8DC56 /* SentrySystemWrapperTests.swift in Sources */,
 				8431EFE529B27BAD00D8DC56 /* SentryNSProcessInfoWrapperTests.swift in Sources */,
 				8431EFDE29B27B5300D8DC56 /* SentryProfilerSwiftTests.swift in Sources */,
diff --git a/SentryTestUtils/SentryTestUtils-ObjC-BridgingHeader.h b/SentryTestUtils/SentryTestUtils-ObjC-BridgingHeader.h
index 60914206b5d..1606cdb2893 100644
--- a/SentryTestUtils/SentryTestUtils-ObjC-BridgingHeader.h
+++ b/SentryTestUtils/SentryTestUtils-ObjC-BridgingHeader.h
@@ -31,7 +31,7 @@
 #import "SentryDispatchQueueWrapper.h"
 #import "SentryDispatchSourceWrapper.h"
 #import "SentryEnvelope.h"
-#import "SentryFileManager+TestProperties.h"
+#import "SentryFileManager+Test.h"
 #import "SentryGlobalEventProcessor.h"
 #import "SentryLog.h"
 #import "SentryNSProcessInfoWrapper.h"
diff --git a/Sources/Sentry/Profiling/SentryLaunchProfiling.m b/Sources/Sentry/Profiling/SentryLaunchProfiling.m
new file mode 100644
index 00000000000..b89fc60bd42
--- /dev/null
+++ b/Sources/Sentry/Profiling/SentryLaunchProfiling.m
@@ -0,0 +1,169 @@
+#import "SentryLaunchProfiling.h"
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+
+#    import "SentryCurrentDateProvider.h"
+#    import "SentryDependencyContainer.h"
+#    import "SentryDispatchQueueWrapper.h"
+#    import "SentryFileManager.h"
+#    import "SentryId.h"
+#    import "SentryInternalDefines.h"
+#    import "SentryLog.h"
+#    import "SentryOptions.h"
+#    import "SentryProfiler.h"
+#    import "SentryRandom.h"
+#    import "SentrySamplerDecision.h"
+#    import "SentrySampling.h"
+#    import "SentrySamplingContext.h"
+#    import "SentryTraceOrigins.h"
+#    import "SentryTracer+Private.h"
+#    import "SentryTracerConfiguration.h"
+#    import "SentryTransactionContext+Private.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+BOOL isTracingAppLaunch;
+NSString *const kSentryLaunchProfileConfigKeyTracesSampleRate = @"traces";
+NSString *const kSentryLaunchProfileConfigKeyProfilesSampleRate = @"profiles";
+static SentryTracer *_Nullable launchTracer;
+
+#    pragma mark - Private
+
+typedef struct {
+    BOOL shouldProfile;
+    SentrySamplerDecision *_Nullable tracesDecision;
+    SentrySamplerDecision *_Nullable profilesDecision;
+} SentryLaunchProfileConfig;
+
+SentryLaunchProfileConfig
+shouldProfileNextLaunch(SentryOptions *options)
+{
+    BOOL shouldProfileNextLaunch = options.enableAppLaunchProfiling && options.enableTracing;
+    if (!shouldProfileNextLaunch) {
+        SENTRY_LOG_DEBUG(@"Won't profile next launch due to specified options configuration: "
+                         @"options.enableAppLaunchProfiling: %d; options.enableTracing: %d",
+            options.enableAppLaunchProfiling, options.enableTracing);
+        return (SentryLaunchProfileConfig) { NO, nil, nil };
+    }
+
+    SentryTransactionContext *transactionContext =
+        [[SentryTransactionContext alloc] initWithName:@"app.launch" operation:@"profile"];
+    transactionContext.forNextAppLaunch = YES;
+    SentrySamplingContext *context =
+        [[SentrySamplingContext alloc] initWithTransactionContext:transactionContext];
+
+    SentrySamplerDecision *tracesSamplerDecision = sampleTrace(context, options);
+    if (tracesSamplerDecision.decision != kSentrySampleDecisionYes) {
+        SENTRY_LOG_DEBUG(@"Sampling out the launch trace.");
+        return (SentryLaunchProfileConfig) { NO, nil, nil };
+    }
+
+    SentrySamplerDecision *profilesSamplerDecision
+        = sampleProfile(context, tracesSamplerDecision, options);
+    if (profilesSamplerDecision.decision != kSentrySampleDecisionYes) {
+        SENTRY_LOG_DEBUG(@"Sampling out the launch profile.");
+        return (SentryLaunchProfileConfig) { NO, nil, nil };
+    }
+
+    SENTRY_LOG_DEBUG(@"Will profile the next launch.");
+    return (SentryLaunchProfileConfig) { YES, tracesSamplerDecision, profilesSamplerDecision };
+}
+
+#    pragma mark - Public
+
+void
+configureLaunchProfiling(SentryOptions *options)
+{
+    [SentryDependencyContainer.sharedInstance.dispatchQueueWrapper dispatchAsyncWithBlock:^{
+        SentryLaunchProfileConfig config = shouldProfileNextLaunch(options);
+        if (!config.shouldProfile) {
+            removeAppLaunchProfilingConfigFile();
+            return;
+        }
+
+        NSMutableDictionary<NSString *, NSNumber *> *configDict =
+            [NSMutableDictionary<NSString *, NSNumber *> dictionary];
+        configDict[kSentryLaunchProfileConfigKeyTracesSampleRate]
+            = config.tracesDecision.sampleRate;
+        configDict[kSentryLaunchProfileConfigKeyProfilesSampleRate]
+            = config.profilesDecision.sampleRate;
+        writeAppLaunchProfilingConfigFile(configDict);
+    }];
+}
+
+SentryTransactionContext *
+context(NSNumber *tracesRate)
+{
+    SentryTransactionContext *context =
+        [[SentryTransactionContext alloc] initWithName:@"launch"
+                                            nameSource:kSentryTransactionNameSourceCustom
+                                             operation:@"app.lifecycle"
+                                                origin:SentryTraceOriginAutoAppStartProfile
+                                               sampled:kSentrySampleDecisionYes];
+    context.sampleRate = tracesRate;
+    return context;
+}
+
+SentryTracerConfiguration *
+config(NSNumber *profilesRate)
+{
+    SentryTracerConfiguration *config = [SentryTracerConfiguration defaultConfiguration];
+    config.profilesSamplerDecision =
+        [[SentrySamplerDecision alloc] initWithDecision:kSentrySampleDecisionYes
+                                          forSampleRate:profilesRate];
+    return config;
+}
+
+void
+startLaunchProfile(void)
+{
+    static dispatch_once_t onceToken;
+    // this function is called from SentryTracer.load but in the future we may expose access
+    // directly to customers, and we'll want to ensure it only runs once. dispatch_once is an
+    // efficient operation so it's fine to leave this in the launch path in any case.
+    dispatch_once(&onceToken, ^{
+        isTracingAppLaunch = appLaunchProfileConfigFileExists();
+        if (!isTracingAppLaunch) {
+            return;
+        }
+
+#    if defined(DEBUG)
+        // quick and dirty way to get debug logging this early in the process run. this will get
+        // overwritten once SentrySDK.startWithOptions is called according to the values of
+        // SentryOptions.debug and SentryOptions.diagnosticLevel
+        [SentryLog configure:YES diagnosticLevel:kSentryLevelDebug];
+#    endif // defined(DEBUG)
+
+        NSDictionary<NSString *, NSNumber *> *rates = appLaunchProfileConfiguration();
+        NSNumber *profilesRate = rates[kSentryLaunchProfileConfigKeyProfilesSampleRate];
+        NSNumber *tracesRate = rates[kSentryLaunchProfileConfigKeyTracesSampleRate];
+        if (profilesRate == nil || tracesRate == nil) {
+            SENTRY_LOG_DEBUG(
+                @"Received a nil configured launch sample rate, will not trace or profile.");
+            return;
+        }
+
+        SENTRY_LOG_INFO(@"Starting app launch profile.");
+        launchTracer = [[SentryTracer alloc] initWithTransactionContext:context(tracesRate)
+                                                                    hub:nil
+                                                          configuration:config(profilesRate)];
+    });
+}
+
+void
+stopLaunchProfile(SentryHub *hub)
+{
+    if (launchTracer == nil) {
+        SENTRY_LOG_DEBUG(@"No launch tracer present to stop.");
+        return;
+    }
+
+    SENTRY_LOG_DEBUG(@"Finishing launch tracer.");
+
+    launchTracer.hub = hub;
+    [launchTracer finish];
+}
+
+NS_ASSUME_NONNULL_END
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Sources/Sentry/Profiling/SentryProfilerState.mm b/Sources/Sentry/Profiling/SentryProfilerState.mm
index 59032cc9cdd..77c14bb74ba 100644
--- a/Sources/Sentry/Profiling/SentryProfilerState.mm
+++ b/Sources/Sentry/Profiling/SentryProfilerState.mm
@@ -115,6 +115,10 @@ - (void)appendBacktrace:(const Backtrace &)backtrace
 #    endif
 
         const auto stack = [NSMutableArray<NSNumber *> array];
+#    if defined(DEBUG)
+        printf("[Sentry] [debug] [SentryProfilerState:%d] stack frames: %lu; stack thread: %s\n",
+            __LINE__, backtrace.addresses.size(), threadID.UTF8String);
+#    endif // defined(DEBUG)
         for (std::vector<uintptr_t>::size_type backtraceAddressIdx = 0;
              backtraceAddressIdx < backtrace.addresses.size(); backtraceAddressIdx++) {
             const auto instructionAddress
@@ -125,8 +129,12 @@ - (void)appendBacktrace:(const Backtrace &)backtrace
                 const auto frame = [NSMutableDictionary<NSString *, id> dictionary];
                 frame[@"instruction_addr"] = instructionAddress;
 #    if defined(DEBUG)
-                frame[@"function"]
+                const auto functionName
                     = parseBacktraceSymbolsFunctionName(symbols[backtraceAddressIdx]);
+                printf("[Sentry] [debug] [SentryProfilerState:%d] function name: %s; instruction "
+                       "address: %s\n",
+                    __LINE__, functionName.UTF8String, instructionAddress.UTF8String);
+                frame[@"function"] = functionName;
 #    endif
                 const auto newFrameIndex = @(state.frames.count);
                 [stack addObject:newFrameIndex];
@@ -137,6 +145,7 @@ - (void)appendBacktrace:(const Backtrace &)backtrace
             }
         }
 #    if defined(DEBUG)
+        printf("-----finished backtrace-----\n");
         free(symbols);
 #    endif
 
diff --git a/Sources/Sentry/Public/SentryOptions.h b/Sources/Sentry/Public/SentryOptions.h
index c7714a631ae..70f930e50a9 100644
--- a/Sources/Sentry/Public/SentryOptions.h
+++ b/Sources/Sentry/Public/SentryOptions.h
@@ -310,6 +310,9 @@ NS_SWIFT_NAME(Options)
  * @c 0.01 collects 1% of all trace data.
  * @note The value needs to be >= 0.0 and \<= 1.0. When setting a value out of range the SDK sets it
  * to the default of @c 0 .
+ * @note If @c enableAppLaunchProfiling is @c YES , this function will be called during SDK start
+ * with @c SentrySamplingContext.forNextAppLaunch set to @c YES, and the result will be persisted to
+ * disk for use on the next app launch.
  */
 @property (nullable, nonatomic) SentryTracesSamplerCallback tracesSampler;
 
@@ -372,6 +375,17 @@ NS_SWIFT_NAME(Options)
 @property (nonatomic, assign) BOOL enableCoreDataTracing;
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
+/**
+ * @warning This is an experimental feature and may still have bugs.
+ * Set to @c YES to run the profiler as early as possible in an app launch, before you would
+ * normally have the opportunity to call @c SentrySDK.start . If enabled, the @c tracesSampleRate
+ * and @c profilesSampleRate are persisted to disk and read on the next app launch to decide whether
+ * to profile that launch.
+ * @see @c tracesSampler and @c profilesSampler for more information on how they work for this
+ * feature.
+ */
+@property (nonatomic, assign) BOOL enableAppLaunchProfiling;
+
 /**
  * @note Profiling is not supported on watchOS or tvOS.
  * Indicates the percentage profiles being sampled out of the sampled transactions.
@@ -389,13 +403,17 @@ NS_SWIFT_NAME(Options)
  * A callback to a user defined profiles sampler function. This is similar to setting
  * @c profilesSampleRate  but instead of a static value, the callback function will be called to
  * determine the sample rate.
+ * @note If @c enableAppLaunchProfiling is @c YES , this function will be called during SDK start
+ * with @c SentrySamplingContext.forNextAppLaunch set to @c YES, and the result will be persisted to
+ * disk for use on the next app launch.
  */
 @property (nullable, nonatomic) SentryTracesSamplerCallback profilesSampler;
 
 /**
+ * If profiling should be enabled or not.
  * @note Profiling is not supported on watchOS or tvOS.
- * If profiling should be enabled or not. Returns @c YES if either a profilesSampleRate > @c 0 and
- * \<= @c 1 or a profilesSampler is set otherwise @c NO.
+ * @returns @c YES if either a profilesSampleRate > @c 0 and \<= @c 1 or a profilesSampler is set,
+ * otherwise @c NO.
  */
 @property (nonatomic, assign, readonly) BOOL isProfilingEnabled;
 
diff --git a/Sources/Sentry/Public/SentryTransactionContext.h b/Sources/Sentry/Public/SentryTransactionContext.h
index 06ca0612d2e..5b58d4c5e98 100644
--- a/Sources/Sentry/Public/SentryTransactionContext.h
+++ b/Sources/Sentry/Public/SentryTransactionContext.h
@@ -26,6 +26,15 @@ SENTRY_NO_INIT
  */
 @property (nonatomic, strong, nullable) NSNumber *sampleRate;
 
+/**
+ * If app launch profiling is enabled via @c SentryOptions.enableAppLaunchProfiling and
+ * @c SentryOptions.tracesSampler and/or @c SentryOptions.profilesSampler are defined,
+ * @c SentrySDK.startWithOptions will call the sampler function with this property set to @c YES ,
+ * and the returned value will be stored to disk for the next launch to calculate a sampling
+ * decision on whether or not to run the profiler.
+ */
+@property (nonatomic, assign) BOOL forNextAppLaunch;
+
 /**
  * @param name Transaction name
  * @param operation The operation this span is measuring.
diff --git a/Sources/Sentry/SentryFileManager.m b/Sources/Sentry/SentryFileManager.m
index f89a46621b1..1f01fd86c6e 100644
--- a/Sources/Sentry/SentryFileManager.m
+++ b/Sources/Sentry/SentryFileManager.m
@@ -11,6 +11,7 @@
 #import "SentryError.h"
 #import "SentryEvent.h"
 #import "SentryFileContents.h"
+#import "SentryInternalDefines.h"
 #import "SentryLog.h"
 #import "SentryMigrateSessionInit.h"
 #import "SentryOptions.h"
@@ -20,6 +21,43 @@
 
 NSString *const EnvelopesPathComponent = @"envelopes";
 
+BOOL
+createDirectoryIfNotExists(NSString *path, NSError **error)
+{
+    if (![[NSFileManager defaultManager] createDirectoryAtPath:path
+                                   withIntermediateDirectories:YES
+                                                    attributes:nil
+                                                         error:error]) {
+        *error = NSErrorFromSentryErrorWithUnderlyingError(kSentryErrorFileIO,
+            [NSString stringWithFormat:@"Failed to create the directory at path %@.", path],
+            *error);
+        return NO;
+    }
+    return YES;
+}
+
+/**
+ * @warning This is called from a `@synchronized` context in instance methods, but doesn't require
+ * that when calling from other static functions. Make sure you pay attention to where this is used
+ * from.
+ */
+void
+_non_thread_safe_removeFileAtPath(NSString *path)
+{
+    NSError *error = nil;
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if (![fileManager removeItemAtPath:path error:&error]) {
+        if (error.code == NSFileNoSuchFileError) {
+            SENTRY_LOG_DEBUG(@"No file to delete at %@", path);
+        } else {
+            SENTRY_LOG_ERROR(
+                @"Error occurred while deleting file at %@ because of %@", path, error);
+        }
+    } else {
+        SENTRY_LOG_DEBUG(@"Successfully deleted file at %@", path);
+    }
+}
+
 @interface
 SentryFileManager ()
 
@@ -65,12 +103,17 @@ - (nullable instancetype)initWithOptions:(SentryOptions *)options
         self.eventsPath = [self.sentryPath stringByAppendingPathComponent:@"events"];
         [self removeFileAtPath:self.eventsPath];
 
-        if (![self createDirectoryIfNotExists:self.sentryPath error:error]) {
+        if (!createDirectoryIfNotExists(self.sentryPath, error)) {
+            return nil;
+        }
+        if (!createDirectoryIfNotExists(self.envelopesPath, error)) {
             return nil;
         }
-        if (![self createDirectoryIfNotExists:self.envelopesPath error:error]) {
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+        if (!createDirectoryIfNotExists(sentryApplicationSupportPath(), error)) {
             return nil;
         }
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
         self.currentFileCounter = 0;
         self.maxEnvelopes = options.maxCacheItems;
@@ -239,7 +282,7 @@ - (void)deleteAllEnvelopes
 {
     [self removeFileAtPath:self.envelopesPath];
     NSError *error;
-    if (![self createDirectoryIfNotExists:self.envelopesPath error:&error]) {
+    if (!createDirectoryIfNotExists(self.envelopesPath, &error)) {
         SENTRY_LOG_ERROR(@"Couldn't create envelopes path.");
     }
 }
@@ -263,19 +306,8 @@ - (void)deleteAllEnvelopes
 
 - (void)removeFileAtPath:(NSString *)path
 {
-    NSFileManager *fileManager = [NSFileManager defaultManager];
-    NSError *error = nil;
     @synchronized(self) {
-        if (![fileManager removeItemAtPath:path error:&error]) {
-            if (error.code == NSFileNoSuchFileError) {
-                SENTRY_LOG_DEBUG(@"No file to delete at %@", path);
-            } else {
-                SENTRY_LOG_ERROR(
-                    @"Error occurred while deleting file at %@ because of %@", path, error);
-            }
-        } else {
-            SENTRY_LOG_DEBUG(@"Successfully deleted file at %@", path);
-        }
+        _non_thread_safe_removeFileAtPath(path);
     }
 }
 
@@ -456,7 +488,7 @@ - (NSDate *_Nullable)readTimestampLastInForeground
 - (BOOL)writeData:(NSData *)data toPath:(NSString *)path
 {
     NSError *error;
-    if (![self createDirectoryIfNotExists:self.sentryPath error:&error]) {
+    if (!createDirectoryIfNotExists(self.sentryPath, &error)) {
         SENTRY_LOG_ERROR(@"File I/O not available at path %@: %@", path, error);
         return NO;
     }
@@ -696,23 +728,94 @@ - (void)createPathsWithOptions:(SentryOptions *)options
     self.envelopesPath = [self.sentryPath stringByAppendingPathComponent:EnvelopesPathComponent];
 }
 
-- (BOOL)createDirectoryIfNotExists:(NSString *)path error:(NSError **)error
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+/**
+ * @note This method must be statically accessible because it will be called during app launch,
+ * before any instance of @c SentryFileManager exists, and so wouldn't be able to access this path
+ * from an objc property on it like the other paths.
+ */
+NSString *_Nullable sentryApplicationSupportPath(void)
+{
+    static NSString *_Nullable sentryApplicationSupportPath = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        NSArray *paths = NSSearchPathForDirectoriesInDomains(
+            NSApplicationSupportDirectory, NSUserDomainMask, YES);
+        NSString *applicationSupportDirectory = [paths firstObject];
+        if (applicationSupportDirectory == nil) {
+            SENTRY_LOG_WARN(@"No application support directory location reported.");
+            return;
+        }
+        sentryApplicationSupportPath =
+            [applicationSupportDirectory stringByAppendingPathComponent:@"io.sentry"];
+    });
+    return sentryApplicationSupportPath;
+}
+
+NSURL *_Nullable sentryLaunchConfigFileURL = nil;
+
+NSURL *_Nullable launchProfileConfigFileURL(void)
 {
-    if (![[NSFileManager defaultManager] createDirectoryAtPath:path
-                                   withIntermediateDirectories:YES
-                                                    attributes:nil
-                                                         error:error]) {
-        *error = NSErrorFromSentryErrorWithUnderlyingError(kSentryErrorFileIO,
-            [NSString stringWithFormat:@"Failed to create the directory at path %@.", path],
-            *error);
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        NSString *appSupportPath = sentryApplicationSupportPath();
+        if (appSupportPath == nil) {
+            SENTRY_LOG_WARN(@"No location available to write a launch profiling config.");
+            return;
+        }
+        sentryLaunchConfigFileURL = [NSURL
+            fileURLWithPath:[appSupportPath stringByAppendingPathComponent:@"profileLaunch"]];
+    });
+    return sentryLaunchConfigFileURL;
+}
+
+NSDictionary<NSString *, NSNumber *> *_Nullable appLaunchProfileConfiguration(void)
+{
+    NSURL *url = launchProfileConfigFileURL();
+    if (![[NSFileManager defaultManager] fileExistsAtPath:url.path]) {
+        return nil;
+    }
+
+    NSError *error;
+    NSDictionary<NSString *, NSNumber *> *config =
+        [NSDictionary<NSString *, NSNumber *> dictionaryWithContentsOfURL:url error:&error];
+    SENTRY_CASSERT(
+        error == nil, @"Encountered error trying to retrieve app launch profile config: %@", error);
+    return config;
+}
+
+BOOL
+appLaunchProfileConfigFileExists(void)
+{
+    NSString *path = launchProfileConfigFileURL().path;
+    if (path == nil) {
         return NO;
     }
-    return YES;
+
+    return access(path.UTF8String, F_OK) == 0;
+}
+
+void
+writeAppLaunchProfilingConfigFile(NSMutableDictionary<NSString *, NSNumber *> *config)
+{
+    NSError *error;
+    SENTRY_CASSERT([config writeToURL:launchProfileConfigFileURL() error:&error],
+        @"Failed to write launch profile config file: %@.", error);
+}
+
+void
+removeAppLaunchProfilingConfigFile(void)
+{
+    _non_thread_safe_removeFileAtPath(launchProfileConfigFileURL().path);
 }
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
 - (void)clearDiskState
 {
     [self removeFileAtPath:self.basePath];
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+    [self removeFileAtPath:sentryApplicationSupportPath()];
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
 }
 
 @end
diff --git a/Sources/Sentry/SentryHub.m b/Sources/Sentry/SentryHub.m
index 7172a17a6c9..ef1727fb722 100644
--- a/Sources/Sentry/SentryHub.m
+++ b/Sources/Sentry/SentryHub.m
@@ -16,13 +16,14 @@
 #import "SentryPerformanceTracker.h"
 #import "SentryProfilingConditionals.h"
 #import "SentrySDK+Private.h"
+#import "SentrySamplerDecision.h"
+#import "SentrySampling.h"
 #import "SentrySamplingContext.h"
 #import "SentryScope+Private.h"
 #import "SentrySerialization.h"
 #import "SentrySession+Private.h"
 #import "SentryTraceOrigins.h"
 #import "SentryTracer.h"
-#import "SentryTracesSampler.h"
 #import "SentryTransaction.h"
 #import "SentryTransactionContext+Private.h"
 
@@ -30,10 +31,6 @@
 #    import "SentryUIViewControllerPerformanceTracker.h"
 #endif // SENTRY_HAS_UIKIT
 
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-#    import "SentryProfilesSampler.h"
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED"
-
 NS_ASSUME_NONNULL_BEGIN
 
 @interface
@@ -42,10 +39,6 @@
 @property (nullable, nonatomic, strong) SentryClient *client;
 @property (nullable, nonatomic, strong) SentryScope *scope;
 @property (nonatomic, strong) SentryCrashWrapper *crashWrapper;
-@property (nonatomic, strong) SentryTracesSampler *tracesSampler;
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-@property (nonatomic, strong) SentryProfilesSampler *profilesSampler;
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED
 @property (nonatomic, strong) NSMutableArray<id<SentryIntegrationProtocol>> *installedIntegrations;
 @property (nonatomic, strong) NSMutableSet<NSString *> *installedIntegrationNames;
 @property (nonatomic) NSUInteger errorsBeforeSession;
@@ -68,13 +61,7 @@ - (instancetype)initWithClient:(nullable SentryClient *)client
         _installedIntegrations = [[NSMutableArray alloc] init];
         _installedIntegrationNames = [[NSMutableSet alloc] init];
         _crashWrapper = [SentryCrashWrapper sharedInstance];
-        _tracesSampler = [[SentryTracesSampler alloc] initWithOptions:client.options];
         _errorsBeforeSession = 0;
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-        if (client.options.isProfilingEnabled) {
-            _profilesSampler = [[SentryProfilesSampler alloc] initWithOptions:client.options];
-        }
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED
     }
     return self;
 }
@@ -386,14 +373,15 @@ - (SentryTracer *)startTransactionWithContext:(SentryTransactionContext *)transa
         [[SentrySamplingContext alloc] initWithTransactionContext:transactionContext
                                             customSamplingContext:customSamplingContext];
 
-    SentryTracesSamplerDecision *samplerDecision = [_tracesSampler sample:samplingContext];
+    SentrySamplerDecision *tracesSamplerDecision
+        = sampleTrace(samplingContext, self.client.options);
     transactionContext = [self transactionContext:transactionContext
-                                      withSampled:samplerDecision.decision];
-    transactionContext.sampleRate = samplerDecision.sampleRate;
+                                      withSampled:tracesSamplerDecision.decision];
+    transactionContext.sampleRate = tracesSamplerDecision.sampleRate;
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-    SentryProfilesSamplerDecision *profilesSamplerDecision =
-        [_profilesSampler sample:samplingContext tracesSamplerDecision:samplerDecision];
+    SentrySamplerDecision *profilesSamplerDecision
+        = sampleProfile(samplingContext, tracesSamplerDecision, self.client.options);
 
     configuration.profilesSamplerDecision = profilesSamplerDecision;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED"
diff --git a/Sources/Sentry/SentryLog.m b/Sources/Sentry/SentryLog.m
index 7b58124463f..4335fc67fd0 100644
--- a/Sources/Sentry/SentryLog.m
+++ b/Sources/Sentry/SentryLog.m
@@ -14,13 +14,10 @@ @implementation SentryLog
 static SentryLogOutput *logOutput;
 static NSObject *logConfigureLock;
 
-+ (void)initialize
-{
-    logConfigureLock = [[NSObject alloc] init];
-}
-
 + (void)configure:(BOOL)debug diagnosticLevel:(SentryLevel)level
 {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{ logConfigureLock = [[NSObject alloc] init]; });
     @synchronized(logConfigureLock) {
         isDebug = debug;
         diagnosticLevel = level;
diff --git a/Sources/Sentry/SentryOptions.m b/Sources/Sentry/SentryOptions.m
index 82a1e4a506e..03d90c2b653 100644
--- a/Sources/Sentry/SentryOptions.m
+++ b/Sources/Sentry/SentryOptions.m
@@ -34,14 +34,6 @@
 #if SENTRY_HAS_METRIC_KIT
 #    import "SentryMetricKitIntegration.h"
 #endif // SENTRY_HAS_METRIC_KIT
-
-@interface
-SentryOptions ()
-
-@property (nullable, nonatomic, copy, readonly) NSNumber *defaultSampleRate;
-
-@end
-
 NSString *const kSentryDefaultEnvironment = @"production";
 
 @implementation SentryOptions {
@@ -98,8 +90,7 @@ - (instancetype)init
         self.maxBreadcrumbs = defaultMaxBreadcrumbs;
         self.maxCacheItems = 30;
         _integrations = SentryOptions.defaultIntegrations;
-        _defaultSampleRate = @1;
-        self.sampleRate = _defaultSampleRate;
+        self.sampleRate = SENTRY_DEFAULT_SAMPLE_RATE;
         self.enableAutoSessionTracking = YES;
         self.enableWatchdogTerminationTracking = YES;
         self.sessionTrackingIntervalMillis = [@30000 unsignedIntValue];
@@ -130,12 +121,10 @@ - (instancetype)init
         self.enableNetworkTracking = YES;
         self.enableFileIOTracing = YES;
         self.enableNetworkBreadcrumbs = YES;
-        _defaultTracesSampleRate = nil;
-        self.tracesSampleRate = _defaultTracesSampleRate;
+        self.tracesSampleRate = nil;
 #if SENTRY_TARGET_PROFILING_SUPPORTED
         _enableProfiling = NO;
-        _defaultProfilesSampleRate = nil;
-        self.profilesSampleRate = _defaultProfilesSampleRate;
+        self.profilesSampleRate = nil;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
         self.enableCoreDataTracing = YES;
         _enableSwizzling = YES;
@@ -469,6 +458,9 @@ - (BOOL)validateOptions:(NSDictionary<NSString *, id> *)options
 
     [self setBool:options[@"enableProfiling"]
             block:^(BOOL value) { self->_enableProfiling = value; }];
+
+    [self setBool:options[NSStringFromSelector(@selector(enableAppLaunchProfiling))]
+            block:^(BOOL value) { self->_enableAppLaunchProfiling = value; }];
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
     [self setBool:options[@"sendClientReports"]
@@ -521,17 +513,18 @@ - (void)setSampleRate:(NSNumber *)sampleRate
 {
     if (sampleRate == nil) {
         _sampleRate = nil;
-    } else if ([self isValidSampleRate:sampleRate]) {
+    } else if (isValidSampleRate(sampleRate)) {
         _sampleRate = sampleRate;
     } else {
-        _sampleRate = _defaultSampleRate;
+        _sampleRate = SENTRY_DEFAULT_SAMPLE_RATE;
     }
 }
 
-- (BOOL)isValidSampleRate:(NSNumber *)sampleRate
+BOOL
+isValidSampleRate(NSNumber *sampleRate)
 {
-    // Same valid range, so we can reuse the logic.
-    return [self isValidTracesSampleRate:sampleRate];
+    double rate = [sampleRate doubleValue];
+    return rate >= 0 && rate <= 1.0;
 }
 
 - (void)setEnableTracing:(BOOL)enableTracing
@@ -551,13 +544,13 @@ - (void)setTracesSampleRate:(NSNumber *)tracesSampleRate
 {
     if (tracesSampleRate == nil) {
         _tracesSampleRate = nil;
-    } else if ([self isValidTracesSampleRate:tracesSampleRate]) {
+    } else if (isValidSampleRate(tracesSampleRate)) {
         _tracesSampleRate = tracesSampleRate;
         if (!_enableTracingManual) {
             _enableTracing = YES;
         }
     } else {
-        _tracesSampleRate = _defaultTracesSampleRate;
+        _tracesSampleRate = SENTRY_DEFAULT_TRACES_SAMPLE_RATE;
     }
 }
 
@@ -569,12 +562,6 @@ - (void)setTracesSampler:(SentryTracesSamplerCallback)tracesSampler
     }
 }
 
-- (BOOL)isValidTracesSampleRate:(NSNumber *)tracesSampleRate
-{
-    double rate = [tracesSampleRate doubleValue];
-    return rate >= 0 && rate <= 1.0;
-}
-
 - (BOOL)isTracingEnabled
 {
     return _enableTracing
@@ -583,19 +570,14 @@ - (BOOL)isTracingEnabled
 }
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-- (BOOL)isValidProfilesSampleRate:(NSNumber *)profilesSampleRate
-{
-    return [self isValidTracesSampleRate:profilesSampleRate];
-}
-
 - (void)setProfilesSampleRate:(NSNumber *)profilesSampleRate
 {
     if (profilesSampleRate == nil) {
         _profilesSampleRate = nil;
-    } else if ([self isValidProfilesSampleRate:profilesSampleRate]) {
+    } else if (isValidSampleRate(profilesSampleRate)) {
         _profilesSampleRate = profilesSampleRate;
     } else {
-        _profilesSampleRate = _defaultProfilesSampleRate;
+        _profilesSampleRate = SENTRY_DEFAULT_PROFILES_SAMPLE_RATE;
     }
 }
 
diff --git a/Sources/Sentry/SentryProfileTimeseries.mm b/Sources/Sentry/SentryProfileTimeseries.mm
index faa3c11bc53..f058c99009b 100644
--- a/Sources/Sentry/SentryProfileTimeseries.mm
+++ b/Sources/Sentry/SentryProfileTimeseries.mm
@@ -46,6 +46,8 @@
         return nil;
     }
 
+    SENTRY_LOG_DEBUG(@"Finding relevant samples from %lu total.", (unsigned long)samples.count);
+
     const auto firstIndex = [samples indexOfObjectPassingTest:^BOOL(
         SentrySample *_Nonnull sample, NSUInteger idx, BOOL *_Nonnull stop) {
         *stop = sample.absoluteTimestamp >= startSystemTime;
diff --git a/Sources/Sentry/SentryProfiler.mm b/Sources/Sentry/SentryProfiler.mm
index c27554a563c..b98753280ec 100644
--- a/Sources/Sentry/SentryProfiler.mm
+++ b/Sources/Sentry/SentryProfiler.mm
@@ -50,6 +50,39 @@
 #        import <UIKit/UIKit.h>
 #    endif // SENTRY_HAS_UIKIT
 
+#    if defined(TEST) || defined(TESTCI) || defined(DEBUG)
+#        import "SentryFileManager.h"
+#        import "SentryInternalDefines.h"
+#        import "SentryLaunchProfiling.h"
+
+/**
+ * A category that overrides its `+[load]` method to deliberately take a long time to run, so we can
+ * see it show up in profile stack traces. Categories' `+[load]` methods are guaranteed to be called
+ * after all of a module's normal class' overrides, so we can be confident the ordering will always
+ * have started the launch profiler by the time this runs.
+ */
+@interface
+SentryProfiler (SlowLoad)
+@end
+
+@implementation
+SentryProfiler (SlowLoad)
++ (void)load
+{
+    SENTRY_LOG_DEBUG(@"Starting slow load method");
+    if ([NSProcessInfo.processInfo.arguments containsObject:@"--io.sentry.slow-load-method"]) {
+        NSMutableString *a = [NSMutableString string];
+        // 1,000,000 iterations takes about 225 milliseconds in the iPhone 15 simulator on an
+        // M2 macbook pro; we might have to adapt this for CI
+        for (NSUInteger i = 0; i < 4000000; i++) {
+            [a appendFormat:@"%d", arc4random() % 12345];
+        }
+    }
+    SENTRY_LOG_DEBUG(@"Finishing slow load method");
+}
+@end
+#    endif // defined(TEST) || defined(TESTCI) || defined(DEBUG)
+
 const int kSentryProfilerFrequencyHz = 101;
 NSTimeInterval kSentryProfilerTimeoutInterval = 30;
 
@@ -376,11 +409,13 @@ + (void)recordMetrics
 + (nullable SentryEnvelopeItem *)createProfilingEnvelopeItemForTransaction:
     (SentryTransaction *)transaction
 {
+    SENTRY_LOG_DEBUG(@"Creating profiling envelope item");
     const auto payload = [self collectProfileBetween:transaction.startSystemTime
                                                  and:transaction.endSystemTime
                                             forTrace:transaction.trace.internalID
                                                onHub:transaction.trace.hub];
     if (payload == nil) {
+        SENTRY_LOG_DEBUG(@"Payload was empty, will not create a profiling envelope item.");
         return nil;
     }
 
@@ -402,6 +437,50 @@ + (nullable SentryEnvelopeItem *)createEnvelopeItemForProfilePayload:
     return [[SentryEnvelopeItem alloc] initWithHeader:header data:JSONData];
 }
 
+#    if defined(TEST) || defined(TESTCI) || defined(DEBUG)
+void
+writeProfileFile(NSDictionary<NSString *, id> *payload)
+{
+    NSData *data = [SentrySerialization dataWithJSONObject:payload];
+    NSFileManager *fm = [NSFileManager defaultManager];
+    NSString *appSupportDirPath = sentryApplicationSupportPath();
+
+    if (![fm fileExistsAtPath:appSupportDirPath]) {
+        SENTRY_LOG_DEBUG(@"Creating app support directory.");
+        NSError *error;
+        if (!SENTRY_CASSERT_RETURN([fm createDirectoryAtPath:appSupportDirPath
+                                       withIntermediateDirectories:NO
+                                                        attributes:nil
+                                                             error:&error],
+                @"Failed to create sentry app support directory")) {
+            return;
+        }
+    } else {
+        SENTRY_LOG_DEBUG(@"App support directory already exists.");
+    }
+
+    NSString *pathToWrite;
+    if (isTracingAppLaunch) {
+        SENTRY_LOG_DEBUG(@"Writing app launch profile.");
+        pathToWrite = [appSupportDirPath stringByAppendingPathComponent:@"launchProfile"];
+    } else {
+        SENTRY_LOG_DEBUG(@"Overwriting last non-launch profile.");
+        pathToWrite = [appSupportDirPath stringByAppendingPathComponent:@"profile"];
+    }
+
+    if ([fm fileExistsAtPath:pathToWrite]) {
+        SENTRY_LOG_DEBUG(@"Already a%@ profile file present; make sure to remove them right after "
+                         @"using them, and that tests clean state in between so there isn't "
+                         @"leftover config producing one when it isn't expected.",
+            isTracingAppLaunch ? @" launch" : @"");
+    }
+
+    SENTRY_LOG_DEBUG(@"Writing%@ profile to file.", isTracingAppLaunch ? @" launch" : @"");
+    SENTRY_CASSERT(
+        [data writeToFile:pathToWrite atomically:YES], @"Failed to write profile to test file");
+}
+#    endif // defined(TEST) || defined(TESTCI) || defined(DEBUG)
+
 + (nullable NSMutableDictionary<NSString *, id> *)collectProfileBetween:(uint64_t)startSystemTime
                                                                     and:(uint64_t)endSystemTime
                                                                forTrace:(SentryId *)traceId
@@ -414,11 +493,10 @@ + (nullable SentryEnvelopeItem *)createEnvelopeItemForProfilePayload:
 
     const auto payload = [profiler serializeBetween:startSystemTime and:endSystemTime onHub:hub];
 
-#    if defined(TEST) || defined(TESTCI)
-    [NSNotificationCenter.defaultCenter postNotificationName:@"SentryProfileCompleteNotification"
-                                                      object:nil
-                                                    userInfo:payload];
-#    endif // defined(TEST) || defined(TESTCI)
+#    if defined(TEST) || defined(TESTCI) || defined(DEBUG)
+    writeProfileFile(payload);
+#    endif // defined(TEST) || defined(TESTCI) || defined(DEBUG)
+
     return payload;
 }
 
diff --git a/Sources/Sentry/SentryProfilesSampler.m b/Sources/Sentry/SentryProfilesSampler.m
deleted file mode 100644
index 8a3a1de63a7..00000000000
--- a/Sources/Sentry/SentryProfilesSampler.m
+++ /dev/null
@@ -1,93 +0,0 @@
-#import "SentryProfilesSampler.h"
-
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-
-#    import "SentryDependencyContainer.h"
-#    import "SentryOptions+Private.h"
-#    import "SentryTracesSampler.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-@implementation SentryProfilesSamplerDecision
-
-- (instancetype)initWithDecision:(SentrySampleDecision)decision
-                   forSampleRate:(nullable NSNumber *)sampleRate
-{
-    if (self = [super init]) {
-        _decision = decision;
-        _sampleRate = sampleRate;
-    }
-    return self;
-}
-
-@end
-
-@implementation SentryProfilesSampler {
-    SentryOptions *_options;
-}
-
-- (instancetype)initWithOptions:(SentryOptions *)options random:(id<SentryRandom>)random
-{
-    if (self = [super init]) {
-        _options = options;
-        self.random = random;
-    }
-    return self;
-}
-
-- (instancetype)initWithOptions:(SentryOptions *)options
-{
-    return [self initWithOptions:options random:[SentryDependencyContainer sharedInstance].random];
-}
-
-- (SentryProfilesSamplerDecision *)sample:(SentrySamplingContext *)context
-                    tracesSamplerDecision:(SentryTracesSamplerDecision *)tracesSamplerDecision
-{
-    // Profiles are always undersampled with respect to traces. If the trace is not sampled,
-    // the profile will not be either. If the trace is sampled, we can proceed to checking
-    // whether the associated profile should be sampled.
-    if (tracesSamplerDecision.decision == kSentrySampleDecisionYes) {
-        if (_options.profilesSampler != nil) {
-            NSNumber *callbackDecision = _options.profilesSampler(context);
-            if (callbackDecision != nil) {
-                if (![_options isValidProfilesSampleRate:callbackDecision]) {
-                    callbackDecision = _options.defaultProfilesSampleRate;
-                }
-            }
-            if (callbackDecision != nil) {
-                return [self calcSample:callbackDecision.doubleValue];
-            }
-        }
-
-        if (_options.profilesSampleRate != nil) {
-            return [self calcSample:_options.profilesSampleRate.doubleValue];
-        }
-
-        // Backward compatibility for clients that are still using the enableProfiling option.
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
-        if (_options.enableProfiling) {
-            return [[SentryProfilesSamplerDecision alloc] initWithDecision:kSentrySampleDecisionYes
-                                                             forSampleRate:@1.0];
-        }
-#    pragma clang diagnostic pop
-    }
-
-    return [[SentryProfilesSamplerDecision alloc] initWithDecision:kSentrySampleDecisionNo
-                                                     forSampleRate:nil];
-}
-
-- (SentryProfilesSamplerDecision *)calcSample:(double)rate
-{
-    double r = [self.random nextNumber];
-    SentrySampleDecision decision = r <= rate ? kSentrySampleDecisionYes : kSentrySampleDecisionNo;
-    return
-        [[SentryProfilesSamplerDecision alloc] initWithDecision:decision
-                                                  forSampleRate:[NSNumber numberWithDouble:rate]];
-}
-
-@end
-
-NS_ASSUME_NONNULL_END
-
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Sources/Sentry/SentrySDK.m b/Sources/Sentry/SentrySDK.m
index b59b1277d0d..4493999fc08 100644
--- a/Sources/Sentry/SentrySDK.m
+++ b/Sources/Sentry/SentrySDK.m
@@ -12,13 +12,22 @@
 #import "SentryDispatchQueueWrapper.h"
 #import "SentryFileManager.h"
 #import "SentryHub+Private.h"
+#import "SentryInternalDefines.h"
 #import "SentryLog.h"
 #import "SentryMeta.h"
 #import "SentryOptions+Private.h"
+#import "SentryProfilingConditionals.h"
+#import "SentrySamplingContext.h"
 #import "SentryScope.h"
+#import "SentrySerialization.h"
 #import "SentryThreadWrapper.h"
+#import "SentryTransactionContext.h"
 #import "SentryUIDeviceWrapper.h"
 
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+#    import "SentryLaunchProfiling.h"
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
 @interface
 SentrySDK ()
 
@@ -177,7 +186,8 @@ + (void)startWithOptions:(SentryOptions *)options
         = options.initialScope([[SentryScope alloc] initWithMaxBreadcrumbs:options.maxBreadcrumbs]);
     // The Hub needs to be initialized with a client so that closing a session
     // can happen.
-    [SentrySDK setCurrentHub:[[SentryHub alloc] initWithClient:newClient andScope:scope]];
+    SentryHub *hub = [[SentryHub alloc] initWithClient:newClient andScope:scope];
+    [SentrySDK setCurrentHub:hub];
     SENTRY_LOG_DEBUG(@"SDK initialized! Version: %@", SentryMeta.versionString);
 
     SENTRY_LOG_DEBUG(@"Dispatching init work required to run on main thread.");
@@ -191,6 +201,13 @@ + (void)startWithOptions:(SentryOptions *)options
 #if TARGET_OS_IOS && SENTRY_HAS_UIKIT
         [SentryDependencyContainer.sharedInstance.uiDeviceWrapper start];
 #endif // TARGET_OS_IOS && SENTRY_HAS_UIKIT
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+        [SentryDependencyContainer.sharedInstance.dispatchQueueWrapper dispatchAsyncWithBlock:^{
+            stopLaunchProfile(hub);
+            configureLaunchProfiling(options);
+        }];
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
     }];
 }
 
diff --git a/Sources/Sentry/SentrySamplerDecision.m b/Sources/Sentry/SentrySamplerDecision.m
new file mode 100644
index 00000000000..d3f2203cae9
--- /dev/null
+++ b/Sources/Sentry/SentrySamplerDecision.m
@@ -0,0 +1,15 @@
+#import "SentrySamplerDecision.h"
+
+@implementation SentrySamplerDecision
+
+- (instancetype)initWithDecision:(SentrySampleDecision)decision
+                   forSampleRate:(nullable NSNumber *)sampleRate
+{
+    if (self = [super init]) {
+        _decision = decision;
+        _sampleRate = sampleRate;
+    }
+    return self;
+}
+
+@end
diff --git a/Sources/Sentry/SentrySampling.m b/Sources/Sentry/SentrySampling.m
new file mode 100644
index 00000000000..a0eda6170b2
--- /dev/null
+++ b/Sources/Sentry/SentrySampling.m
@@ -0,0 +1,117 @@
+#import "SentrySampling.h"
+#import "SentryDependencyContainer.h"
+#import "SentryInternalDefines.h"
+#import "SentryOptions.h"
+#import "SentryRandom.h"
+#import "SentrySampleDecision.h"
+#import "SentrySamplerDecision.h"
+#import "SentrySamplingContext.h"
+#import "SentryTransactionContext.h"
+#import <SentryOptions+Private.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+#pragma mark - Private
+
+/**
+ * @return A sample rate if the specified sampler callback was defined on @c SentryOptions and
+ * returned a valid value, @c nil otherwise.
+ */
+NSNumber *_Nullable samplerCallbackRate(SentryTracesSamplerCallback _Nullable callback,
+    SentrySamplingContext *context, NSNumber *defaultSampleRate)
+{
+    if (callback == nil) {
+        return nil;
+    }
+
+    NSNumber *callbackRate = callback(context);
+    if (!isValidSampleRate(callbackRate)) {
+        return defaultSampleRate;
+    }
+
+    return callbackRate;
+}
+
+SentrySamplerDecision *
+calcSample(NSNumber *rate)
+{
+    double random = [SentryDependencyContainer.sharedInstance.random nextNumber];
+    SentrySampleDecision decision
+        = random <= rate.doubleValue ? kSentrySampleDecisionYes : kSentrySampleDecisionNo;
+    return [[SentrySamplerDecision alloc] initWithDecision:decision forSampleRate:rate];
+}
+
+SentrySamplerDecision *
+calcSampleFromNumericalRate(NSNumber *rate)
+{
+    if (rate == nil) {
+        return [[SentrySamplerDecision alloc] initWithDecision:kSentrySampleDecisionNo
+                                                 forSampleRate:nil];
+    }
+
+    return calcSample(rate);
+}
+
+#pragma mark - Public
+
+SentrySamplerDecision *
+sampleTrace(SentrySamplingContext *context, SentryOptions *options)
+{
+    // check this transaction's sampling decision, if already decided
+    if (context.transactionContext.sampled != kSentrySampleDecisionUndecided) {
+        return
+            [[SentrySamplerDecision alloc] initWithDecision:context.transactionContext.sampled
+                                              forSampleRate:context.transactionContext.sampleRate];
+    }
+
+    NSNumber *callbackRate
+        = samplerCallbackRate(options.tracesSampler, context, SENTRY_DEFAULT_TRACES_SAMPLE_RATE);
+    if (callbackRate != nil) {
+        return calcSample(callbackRate);
+    }
+
+    // check the _parent_ transaction's sampling decision, if any
+    if (context.transactionContext.parentSampled != kSentrySampleDecisionUndecided) {
+        return
+            [[SentrySamplerDecision alloc] initWithDecision:context.transactionContext.parentSampled
+                                              forSampleRate:context.transactionContext.sampleRate];
+    }
+
+    return calcSampleFromNumericalRate(options.tracesSampleRate);
+}
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+
+SentrySamplerDecision *
+sampleProfile(SentrySamplingContext *context, SentrySamplerDecision *tracesSamplerDecision,
+    SentryOptions *options)
+{
+    // Profiles are always undersampled with respect to traces. If the trace is not sampled,
+    // the profile will not be either. If the trace is sampled, we can proceed to checking
+    // whether the associated profile should be sampled.
+    if (tracesSamplerDecision.decision != kSentrySampleDecisionYes) {
+        return [[SentrySamplerDecision alloc] initWithDecision:kSentrySampleDecisionNo
+                                                 forSampleRate:nil];
+    }
+
+    // Backward compatibility for clients that are still using the enableProfiling option.
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    if (options.enableProfiling) {
+        return [[SentrySamplerDecision alloc] initWithDecision:kSentrySampleDecisionYes
+                                                 forSampleRate:@1.0];
+    }
+#    pragma clang diagnostic pop
+
+    NSNumber *callbackRate = samplerCallbackRate(
+        options.profilesSampler, context, SENTRY_DEFAULT_PROFILES_SAMPLE_RATE);
+    if (callbackRate != nil) {
+        return calcSample(callbackRate);
+    }
+
+    return calcSampleFromNumericalRate(options.profilesSampleRate);
+}
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/SentryTracer.m b/Sources/Sentry/SentryTracer.m
index 06294436ee0..883efc34905 100644
--- a/Sources/Sentry/SentryTracer.m
+++ b/Sources/Sentry/SentryTracer.m
@@ -5,12 +5,16 @@
 #import "SentryDebugImageProvider.h"
 #import "SentryDependencyContainer.h"
 #import "SentryEvent+Private.h"
+#import "SentryFileManager.h"
 #import "SentryHub+Private.h"
+#import "SentryInternalDefines.h"
 #import "SentryLog.h"
 #import "SentryNSTimerFactory.h"
 #import "SentryNoOpSpan.h"
 #import "SentryProfilingConditionals.h"
+#import "SentryRandom.h"
 #import "SentrySDK+Private.h"
+#import "SentrySamplerDecision.h"
 #import "SentryScope.h"
 #import "SentrySpan.h"
 #import "SentrySpanContext+Private.h"
@@ -31,9 +35,9 @@
 @import SentryPrivate;
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
+#    import "SentryLaunchProfiling.h"
 #    import "SentryProfiledTracerConcurrency.h"
 #    import "SentryProfiler.h"
-#    import "SentryProfilesSampler.h"
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
 #if SENTRY_HAS_UIKIT
@@ -44,6 +48,11 @@
 #    import <SentryScreenFrames.h>
 #endif // SENTRY_HAS_UIKIT
 
+#if defined(TEST) || defined(TESTCI)
+#    import "SentryFileManager+Test.h"
+#    import "SentryInternalDefines.h"
+#endif // defined(TEST) || defined(TESTCI)
+
 NS_ASSUME_NONNULL_BEGIN
 
 static const void *spanTimestampObserver = &spanTimestampObserver;
@@ -104,6 +113,13 @@ @implementation SentryTracer {
 static NSObject *appStartMeasurementLock;
 static BOOL appStartMeasurementRead;
 
+#if SENTRY_TARGET_PROFILING_SUPPORTED
++ (void)load
+{
+    startLaunchProfile();
+}
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
 + (void)initialize
 {
     if (self == [SentryTracer class]) {
@@ -176,10 +192,16 @@ - (instancetype)initWithTransactionContext:(SentryTransactionContext *)transacti
 #if SENTRY_TARGET_PROFILING_SUPPORTED
     if (_configuration.profilesSamplerDecision.decision == kSentrySampleDecisionYes) {
         _internalID = [[SentryId alloc] init];
-        _isProfiling = [SentryProfiler startWithTracer:_internalID];
+        if ((_isProfiling = [SentryProfiler startWithTracer:_internalID])) {
+            SENTRY_LOG_DEBUG(@"Started profiler for trace %@ with internal id %@",
+                transactionContext.traceId.sentryIdString, _internalID.sentryIdString);
+        }
+        _startSystemTime = SentryDependencyContainer.sharedInstance.dateProvider.systemTime;
     }
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
+    SENTRY_LOG_DEBUG(@"Started tracer with id: %@", transactionContext.traceId.sentryIdString);
+
     return self;
 }
 
@@ -491,10 +513,13 @@ - (void)finishInternal
 {
     [self cancelDeadlineTimer];
     if (self.isFinished) {
+        SENTRY_LOG_DEBUG(@"Tracer %@ was already finished.", _traceContext.traceId.sentryIdString);
         return;
     }
     @synchronized(self) {
         if (self.isFinished) {
+            SENTRY_LOG_DEBUG(@"Tracer %@ was already finished after synchronizing.",
+                _traceContext.traceId.sentryIdString);
             return;
         }
         // Keep existing status of auto generated transactions if set by the user.
@@ -539,7 +564,15 @@ - (void)finishInternal
         return;
     }
 
-    if (_hub == nil) {
+    BOOL shouldBailWithNilHub = _hub == nil;
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+    if (isTracingAppLaunch) {
+        shouldBailWithNilHub = NO;
+    }
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+    if (shouldBailWithNilHub) {
+        SENTRY_LOG_DEBUG(
+            @"Hub was nil for tracer %@, nothing to do.", _traceContext.traceId.sentryIdString);
         return;
     }
 
@@ -651,12 +684,14 @@ - (SentryTransaction *)toTransaction
 
     SentryTransaction *transaction = [[SentryTransaction alloc] initWithTrace:self children:spans];
     transaction.transaction = self.transactionContext.name;
+
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-    transaction.startSystemTime = self.startSystemTime;
     if (self.isProfiling) {
+        transaction.startSystemTime = self.startSystemTime;
         [SentryProfiler recordMetrics];
+        transaction.endSystemTime
+            = SentryDependencyContainer.sharedInstance.dateProvider.systemTime;
     }
-    transaction.endSystemTime = SentryDependencyContainer.sharedInstance.dateProvider.systemTime;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
     NSMutableArray *framesOfAllSpans = [NSMutableArray array];
diff --git a/Sources/Sentry/SentryTracesSampler.m b/Sources/Sentry/SentryTracesSampler.m
deleted file mode 100644
index 3727771a3df..00000000000
--- a/Sources/Sentry/SentryTracesSampler.m
+++ /dev/null
@@ -1,84 +0,0 @@
-#import "SentryTracesSampler.h"
-#import "SentryDependencyContainer.h"
-#import "SentryOptions.h"
-#import "SentrySamplingContext.h"
-#import "SentryTransactionContext.h"
-#import <SentryOptions+Private.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@implementation SentryTracesSamplerDecision
-
-- (instancetype)initWithDecision:(SentrySampleDecision)decision
-                   forSampleRate:(nullable NSNumber *)sampleRate
-{
-    if (self = [super init]) {
-        _decision = decision;
-        _sampleRate = sampleRate;
-    }
-    return self;
-}
-
-@end
-
-@implementation SentryTracesSampler {
-    SentryOptions *_options;
-}
-
-- (instancetype)initWithOptions:(SentryOptions *)options random:(id<SentryRandom>)random
-{
-    if (self = [super init]) {
-        _options = options;
-        self.random = random;
-    }
-    return self;
-}
-
-- (instancetype)initWithOptions:(SentryOptions *)options
-{
-    return [self initWithOptions:options random:[SentryDependencyContainer sharedInstance].random];
-}
-
-- (SentryTracesSamplerDecision *)sample:(SentrySamplingContext *)context
-{
-    if (context.transactionContext.sampled != kSentrySampleDecisionUndecided) {
-        return [[SentryTracesSamplerDecision alloc]
-            initWithDecision:context.transactionContext.sampled
-               forSampleRate:context.transactionContext.sampleRate];
-    }
-
-    if (_options.tracesSampler != nil) {
-        NSNumber *callbackDecision = _options.tracesSampler(context);
-        if (callbackDecision != nil) {
-            if (![_options isValidTracesSampleRate:callbackDecision]) {
-                callbackDecision = _options.defaultTracesSampleRate;
-            }
-        }
-        if (callbackDecision != nil) {
-            return [self calcSample:callbackDecision.doubleValue];
-        }
-    }
-
-    if (context.transactionContext.parentSampled != kSentrySampleDecisionUndecided)
-        return [[SentryTracesSamplerDecision alloc]
-            initWithDecision:context.transactionContext.parentSampled
-               forSampleRate:context.transactionContext.sampleRate];
-
-    if (_options.tracesSampleRate != nil)
-        return [self calcSample:_options.tracesSampleRate.doubleValue];
-
-    return [[SentryTracesSamplerDecision alloc] initWithDecision:kSentrySampleDecisionNo
-                                                   forSampleRate:nil];
-}
-
-- (SentryTracesSamplerDecision *)calcSample:(double)rate
-{
-    double r = [self.random nextNumber];
-    SentrySampleDecision decision = r <= rate ? kSentrySampleDecisionYes : kSentrySampleDecisionNo;
-    return [[SentryTracesSamplerDecision alloc] initWithDecision:decision
-                                                   forSampleRate:[NSNumber numberWithDouble:rate]];
-}
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentryFileManager.h b/Sources/Sentry/include/SentryFileManager.h
index d4b36615c8f..cb774591c79 100644
--- a/Sources/Sentry/include/SentryFileManager.h
+++ b/Sources/Sentry/include/SentryFileManager.h
@@ -1,5 +1,6 @@
 #import "SentryDataCategory.h"
 #import "SentryDefines.h"
+#import "SentryProfilingConditionals.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -13,6 +14,11 @@ NS_ASSUME_NONNULL_BEGIN
 @class SentryOptions;
 @class SentrySession;
 
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+SENTRY_EXTERN NSString *sentryApplicationSupportPath(void);
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
+NS_SWIFT_NAME(SentryFileManager)
 @interface SentryFileManager : NSObject
 SENTRY_NO_INIT
 
@@ -87,6 +93,39 @@ SENTRY_NO_INIT
 - (void)storeTimezoneOffset:(NSInteger)offset;
 - (void)deleteTimezoneOffset;
 
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+/**
+ * @return @c YES if a launch profile config file is present, @c NO otherwise. If a config file is
+ * present, this means that a sample decision of @c YES was computed using the resolved traces and
+ * profiles sample rates provided in the previous launch's call to @c SentrySDK.startWithOptions .
+ * @note This is implemented as a C function instead of an Objective-C method in the interest of
+ * fast execution at launch time.
+ */
+SENTRY_EXTERN BOOL appLaunchProfileConfigFileExists(void);
+
+/**
+ * Retrieve the contents of the launch profile config file, which stores the sample rates used to
+ * decide whether or not to profile this launch.
+ */
+SENTRY_EXTERN NSDictionary<NSString *, NSNumber *> *_Nullable appLaunchProfileConfiguration(void);
+
+/**
+ * Write a config file that stores the sample rates used to determine whether this launch should
+ * have been profiled.
+ */
+SENTRY_EXTERN void writeAppLaunchProfilingConfigFile(
+    NSMutableDictionary<NSString *, NSNumber *> *config);
+
+/**
+ * Remove an existing launch profile config file. If this launch was profiled, then a config file is
+ * present, and if the following call to @c SentrySDK.startWithOptions determines the next launch
+ * should not be profiled, then we must remove the config file, or the next launch would see it and
+ * start the profiler.
+ */
+SENTRY_EXTERN void removeAppLaunchProfilingConfigFile(void);
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
 @end
 
 @protocol SentryFileManagerDelegate <NSObject>
diff --git a/Sources/Sentry/include/SentryInternalDefines.h b/Sources/Sentry/include/SentryInternalDefines.h
index c4718d0f0e0..7a528138ae0 100644
--- a/Sources/Sentry/include/SentryInternalDefines.h
+++ b/Sources/Sentry/include/SentryInternalDefines.h
@@ -4,6 +4,10 @@
 static NSString *const SentryDebugImageType = @"macho";
 static NSString *const SentryPlatformName = @"cocoa";
 
+#define SENTRY_DEFAULT_SAMPLE_RATE @1
+#define SENTRY_DEFAULT_TRACES_SAMPLE_RATE @0
+#define SENTRY_DEFAULT_PROFILES_SAMPLE_RATE @0
+
 /**
  * Abort in debug, and log a warning in production.
  */
@@ -36,7 +40,7 @@ static NSString *const SentryPlatformName = @"cocoa";
  */
 #define SENTRY_ASSERT_RETURN(cond, ...)                                                            \
     ({                                                                                             \
-        const auto __cond_result = (cond);                                                         \
+        BOOL __cond_result = (cond);                                                               \
         if (!__cond_result) {                                                                      \
             SENTRY_LOG_WARN(__VA_ARGS__);                                                          \
             NSAssert(NO, __VA_ARGS__);                                                             \
@@ -51,7 +55,7 @@ static NSString *const SentryPlatformName = @"cocoa";
  */
 #define SENTRY_CASSERT_RETURN(cond, ...)                                                           \
     ({                                                                                             \
-        const auto __cond_result = (cond);                                                         \
+        BOOL __cond_result = (cond);                                                               \
         if (!__cond_result) {                                                                      \
             SENTRY_LOG_WARN(__VA_ARGS__);                                                          \
             NSCAssert(NO, __VA_ARGS__);                                                            \
diff --git a/Sources/Sentry/include/SentryLaunchProfiling.h b/Sources/Sentry/include/SentryLaunchProfiling.h
new file mode 100644
index 00000000000..d7d98634395
--- /dev/null
+++ b/Sources/Sentry/include/SentryLaunchProfiling.h
@@ -0,0 +1,33 @@
+#import "SentryDefines.h"
+#import "SentryProfilingConditionals.h"
+#import <Foundation/Foundation.h>
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+
+@class SentryHub;
+@class SentryId;
+@class SentryOptions;
+@class SentryTracerConfiguration;
+@class SentryTransactionContext;
+
+NS_ASSUME_NONNULL_BEGIN
+
+SENTRY_EXTERN BOOL isTracingAppLaunch;
+
+/** Try to start a profiled trace for this app launch, if the configuration allows. */
+SENTRY_EXTERN void startLaunchProfile(void);
+
+/** Stop any profiled trace that may be in flight from the start of the app launch. */
+void stopLaunchProfile(SentryHub *hub);
+
+/**
+ * Write a file to disk containing sample rates for profiles and traces. The presence of this file
+ * will let the profiler know to start on the app launch, and the sample rates contained will help
+ * thread sampling decisions through to SentryHub later when it needs to start a transaction for the
+ * profile to be attached to.
+ */
+void configureLaunchProfiling(SentryOptions *options);
+
+NS_ASSUME_NONNULL_END
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Sources/Sentry/include/SentryOptions+Private.h b/Sources/Sentry/include/SentryOptions+Private.h
index 8c23aa150df..ac3a47abef7 100644
--- a/Sources/Sentry/include/SentryOptions+Private.h
+++ b/Sources/Sentry/include/SentryOptions+Private.h
@@ -6,21 +6,11 @@ FOUNDATION_EXPORT NSString *const kSentryDefaultEnvironment;
 
 @interface
 SentryOptions ()
-
-@property (nullable, nonatomic, copy, readonly) NSNumber *defaultTracesSampleRate;
-
 #if SENTRY_TARGET_PROFILING_SUPPORTED
-@property (nullable, nonatomic, copy, readonly) NSNumber *defaultProfilesSampleRate;
 @property (nonatomic, assign) BOOL enableProfiling_DEPRECATED_TEST_ONLY;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
-- (BOOL)isValidSampleRate:(NSNumber *)sampleRate;
-
-- (BOOL)isValidTracesSampleRate:(NSNumber *)tracesSampleRate;
-
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-- (BOOL)isValidProfilesSampleRate:(NSNumber *)profilesSampleRate;
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+SENTRY_EXTERN BOOL isValidSampleRate(NSNumber *sampleRate);
 
 @end
 
diff --git a/Sources/Sentry/include/SentryProfilesSampler.h b/Sources/Sentry/include/SentryProfilesSampler.h
deleted file mode 100644
index d07ac8320de..00000000000
--- a/Sources/Sentry/include/SentryProfilesSampler.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#import "SentryProfilingConditionals.h"
-
-#if SENTRY_TARGET_PROFILING_SUPPORTED
-
-#    import "SentryRandom.h"
-#    import "SentrySampleDecision.h"
-#    import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@class SentryOptions, SentrySamplingContext, SentryTracesSamplerDecision;
-
-@interface SentryProfilesSamplerDecision : NSObject
-
-@property (nonatomic, readonly) SentrySampleDecision decision;
-
-@property (nullable, nonatomic, strong, readonly) NSNumber *sampleRate;
-
-- (instancetype)initWithDecision:(SentrySampleDecision)decision
-                   forSampleRate:(nullable NSNumber *)sampleRate;
-
-@end
-
-@interface SentryProfilesSampler : NSObject
-
-/**
- *  A random number generator
- */
-@property (nonatomic, strong) id<SentryRandom> random;
-
-/**
- * Init a ProfilesSampler with given options and random generator.
- * @param options Sentry options with sampling configuration
- * @param random A random number generator
- */
-- (instancetype)initWithOptions:(SentryOptions *)options random:(id<SentryRandom>)random;
-
-/**
- * Init a ProfilesSampler with given options and a default Random generator.
- * @param options Sentry options with sampling configuration
- */
-- (instancetype)initWithOptions:(SentryOptions *)options;
-
-/**
- * Determines whether a profile should be sampled based on the context, options, and
- * whether the trace corresponding to the profile was sampled.
- */
-- (SentryProfilesSamplerDecision *)sample:(SentrySamplingContext *)context
-                    tracesSamplerDecision:(SentryTracesSamplerDecision *)tracesSamplerDecision;
-
-@end
-
-NS_ASSUME_NONNULL_END
-
-#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Sources/Sentry/include/SentrySamplerDecision.h b/Sources/Sentry/include/SentrySamplerDecision.h
new file mode 100644
index 00000000000..8b115653524
--- /dev/null
+++ b/Sources/Sentry/include/SentrySamplerDecision.h
@@ -0,0 +1,17 @@
+#import "SentrySampleDecision.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SentrySamplerDecision : NSObject
+
+@property (nonatomic, readonly) SentrySampleDecision decision;
+
+@property (nullable, nonatomic, strong, readonly) NSNumber *sampleRate;
+
+- (instancetype)initWithDecision:(SentrySampleDecision)decision
+                   forSampleRate:(nullable NSNumber *)sampleRate;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentrySampling.h b/Sources/Sentry/include/SentrySampling.h
new file mode 100644
index 00000000000..5c404b91131
--- /dev/null
+++ b/Sources/Sentry/include/SentrySampling.h
@@ -0,0 +1,24 @@
+#import "SentryProfilingConditionals.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SentryOptions;
+@class SentrySamplerDecision;
+@class SentrySamplingContext;
+
+/**
+ * Determines whether a trace should be sampled based on the context and options.
+ */
+SentrySamplerDecision *sampleTrace(SentrySamplingContext *context, SentryOptions *options);
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+/**
+ * Determines whether a profile should be sampled based on the context, options, and
+ * whether the trace corresponding to the profile was sampled.
+ */
+SentrySamplerDecision *sampleProfile(SentrySamplingContext *context,
+    SentrySamplerDecision *tracesSamplerDecision, SentryOptions *options);
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentryTraceOrigins.h b/Sources/Sentry/include/SentryTraceOrigins.h
index 9be87b76a76..7922cdb9a7c 100644
--- a/Sources/Sentry/include/SentryTraceOrigins.h
+++ b/Sources/Sentry/include/SentryTraceOrigins.h
@@ -4,6 +4,7 @@ static NSString *const SentryTraceOriginManual = @"manual";
 static NSString *const SentryTraceOriginUIEventTracker = @"auto.ui.event_tracker";
 
 static NSString *const SentryTraceOriginAutoAppStart = @"auto.app.start";
+static NSString *const SentryTraceOriginAutoAppStartProfile = @"auto.app.start.profile";
 static NSString *const SentryTraceOriginAutoNSData = @"auto.file.ns_data";
 static NSString *const SentryTraceOriginAutoDBCoreData = @"auto.db.core_data";
 static NSString *const SentryTraceOriginAutoHttpNSURLSession = @"auto.http.ns_url_session";
diff --git a/Sources/Sentry/include/SentryTracer.h b/Sources/Sentry/include/SentryTracer.h
index 728af54946e..e4f9a891546 100644
--- a/Sources/Sentry/include/SentryTracer.h
+++ b/Sources/Sentry/include/SentryTracer.h
@@ -1,3 +1,5 @@
+#import "SentryDefines.h"
+#import "SentryProfilingConditionals.h"
 #import "SentrySpan.h"
 #import "SentrySpanProtocol.h"
 #import "SentryTracerConfiguration.h"
@@ -5,9 +7,14 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@class SentryHub, SentryTransactionContext, SentryTraceHeader, SentryTraceContext,
-    SentryNSTimerFactory, SentryDispatchQueueWrapper, SentryTracer, SentryProfilesSamplerDecision,
-    SentryMeasurementValue;
+@class SentryDispatchQueueWrapper;
+@class SentryHub;
+@class SentryMeasurementValue;
+@class SentryNSTimerFactory;
+@class SentryTraceContext;
+@class SentryTraceHeader;
+@class SentryTracer;
+@class SentryTransactionContext;
 
 static NSTimeInterval const SentryTracerDefaultTimeout = 3.0;
 
diff --git a/Sources/Sentry/include/SentryTracerConfiguration.h b/Sources/Sentry/include/SentryTracerConfiguration.h
index 5b81a0ffbb4..9fdb9c228c7 100644
--- a/Sources/Sentry/include/SentryTracerConfiguration.h
+++ b/Sources/Sentry/include/SentryTracerConfiguration.h
@@ -8,7 +8,9 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@class SentryNSTimerFactory, SentryDispatchQueueWrapper, SentryProfilesSamplerDecision;
+@class SentryDispatchQueueWrapper;
+@class SentryNSTimerFactory;
+@class SentrySamplerDecision;
 
 @interface SentryTracerConfiguration : NSObject
 
@@ -30,7 +32,7 @@ NS_ASSUME_NONNULL_BEGIN
 /**
  * Whether to sample a profile corresponding to this transaction
  */
-@property (nonatomic, strong, nullable) SentryProfilesSamplerDecision *profilesSamplerDecision;
+@property (nonatomic, strong, nullable) SentrySamplerDecision *profilesSamplerDecision;
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED"
 
 /**
diff --git a/Sources/Sentry/include/SentryTracesSampler.h b/Sources/Sentry/include/SentryTracesSampler.h
deleted file mode 100644
index 5d8dfa06397..00000000000
--- a/Sources/Sentry/include/SentryTracesSampler.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#import "SentryRandom.h"
-#import "SentrySampleDecision.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-@class SentryOptions, SentrySamplingContext;
-
-@interface SentryTracesSamplerDecision : NSObject
-
-@property (nonatomic, readonly) SentrySampleDecision decision;
-
-@property (nullable, nonatomic, strong, readonly) NSNumber *sampleRate;
-
-- (instancetype)initWithDecision:(SentrySampleDecision)decision
-                   forSampleRate:(nullable NSNumber *)sampleRate;
-
-@end
-
-@interface SentryTracesSampler : NSObject
-
-/**
- *  A random number generator
- */
-@property (nonatomic, strong) id<SentryRandom> random;
-
-/**
- * Init a TracesSampler with given options and random generator.
- * @param options Sentry options with sampling configuration
- * @param random A random number generator
- */
-- (instancetype)initWithOptions:(SentryOptions *)options random:(id<SentryRandom>)random;
-
-/**
- * Init a TracesSampler with given options and a default Random generator.
- * @param options Sentry options with sampling configuration
- */
-- (instancetype)initWithOptions:(SentryOptions *)options;
-
-/**
- * Determines whether a trace should be sampled based on the context and options.
- */
-- (SentryTracesSamplerDecision *)sample:(SentrySamplingContext *)context;
-
-@end
-
-NS_ASSUME_NONNULL_END
diff --git a/Tests/SentryProfilerTests/SentryAppLaunchProfilingTests.m b/Tests/SentryProfilerTests/SentryAppLaunchProfilingTests.m
new file mode 100644
index 00000000000..45270a23cb9
--- /dev/null
+++ b/Tests/SentryProfilerTests/SentryAppLaunchProfilingTests.m
@@ -0,0 +1,151 @@
+#import "SentryLaunchProfiling+Tests.h"
+#import "SentryOptions+HybridSDKs.h"
+#import "SentryOptions+Private.h"
+#import "SentryProfilingConditionals.h"
+#import "SentrySDK+Tests.h"
+#import "SentryTraceOrigins.h"
+#import "SentryTransactionContext.h"
+#import <XCTest/XCTest.h>
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+
+@interface SentryAppLaunchProfilingTests : XCTestCase
+@end
+
+@implementation SentryAppLaunchProfilingTests
+
+- (void)testLaunchProfileTransactionContext
+{
+    SentryTransactionContext *actualContext = context(@1);
+    XCTAssertEqual(actualContext.nameSource, kSentryTransactionNameSourceCustom);
+    XCTAssert([actualContext.origin isEqualToString:SentryTraceOriginAutoAppStartProfile]);
+    XCTAssert(actualContext.sampled);
+}
+
+#    define SENTRY_OPTION(name, value)                                                             \
+        NSStringFromSelector(@selector(name))                                                      \
+            : value
+
+- (void)testDefaultOptionsDoNotEnableLaunchProfiling
+{
+    XCTAssertFalse(shouldProfileNextLaunch([self defaultOptionsWithOverrides:nil]).shouldProfile,
+        @"Default options should not enable launch profiling");
+}
+
+- (void)testAppLaunchProfilingNotSufficientToEnableLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultOptionsWithOverrides:@{ SENTRY_OPTION(enableAppLaunchProfiling, @YES) }])
+            .shouldProfile,
+        @"Default options with only launch profiling option set is not sufficient to enable launch "
+        @"profiling");
+}
+
+- (void)testAppLaunchProfilingAndTracingOptionsNotSufficientToEnableAppLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultOptionsWithOverrides:@{ SENTRY_OPTION(enableAppLaunchProfiling, @YES),
+                                                  SENTRY_OPTION(enableTracing, @YES) }])
+            .shouldProfile,
+        @"Default options with app launch profiling and tracing enabled are not sufficient to "
+        @"enable launch profiling");
+}
+
+- (void)
+    testAppLaunchProfilingAndTracingAndTracesSampleRateOptionsNotSufficientToEnableAppLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultOptionsWithOverrides:@{ SENTRY_OPTION(enableAppLaunchProfiling, @YES),
+                                                  SENTRY_OPTION(enableTracing, @YES),
+                                                  SENTRY_OPTION(tracesSampleRate, @1) }])
+            .shouldProfile,
+        @"Default options with app launch profiling and tracing enabled with traces sample rate of "
+        @"1 are not sufficient to enable launch profiling");
+}
+
+- (void)testMinimumOptionsRequiredToEnableAppLaunchProfiling
+{
+    XCTAssert(shouldProfileNextLaunch([self defaultLaunchProfilingOptionsWithOverrides:nil])
+                  .shouldProfile,
+        @"Default options with app launch profiling and tracing enabled and traces and profiles "
+        @"sample rates of 1 should enable launch profiling");
+}
+
+- (void)testDisablingLaunchProfilingOptionDisablesAppLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultLaunchProfilingOptionsWithOverrides:@{ SENTRY_OPTION(
+                                                                 enableAppLaunchProfiling, @NO) }])
+            .shouldProfile,
+        @"Default options with tracing enabled, traces and profiles sample rates of 1, but app "
+        @"launch profiling disabled should not enable launch profiling");
+}
+
+- (void)testDisablingTracingOptionDisablesAppLaunchProfiling
+{
+    XCTAssertFalse(shouldProfileNextLaunch(
+                       [self defaultLaunchProfilingOptionsWithOverrides:@{ SENTRY_OPTION(
+                                                                            enableTracing, @NO) }])
+                       .shouldProfile,
+        @"Default options with app launch profiling enabled, traces and profiles sample rates of "
+        @"1, but tracing disabled should not enable launch profiling");
+}
+
+- (void)testSettingTracesSampleRateTo0DisablesAppLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultLaunchProfilingOptionsWithOverrides:@{ SENTRY_OPTION(
+                                                                 tracesSampleRate, @0) }])
+            .shouldProfile,
+        @"Default options with app launch profiling and tracing enabled, profiles sample rate of "
+        @"1, but traces sample rate of 0 should not enable launch profiling");
+}
+
+- (void)testSettingProfilesSampleRateTo0DisablesAppLaunchProfiling
+{
+    XCTAssertFalse(
+        shouldProfileNextLaunch(
+            [self defaultLaunchProfilingOptionsWithOverrides:@{ SENTRY_OPTION(
+                                                                 profilesSampleRate, @0) }])
+            .shouldProfile,
+        @"Default options with app launch profiling and tracing enabled, traces sample rate of 1, "
+        @"but profiles sample rate of 0 should not enable launch profiling");
+}
+
+#    pragma mark - Private
+
+- (SentryOptions *)defaultLaunchProfilingOptionsWithOverrides:
+    (NSDictionary<NSString *, id> *)overrides
+{
+    NSMutableDictionary<NSString *, id> *options = [NSMutableDictionary<NSString *, id>
+        dictionaryWithDictionary:@{ SENTRY_OPTION(enableAppLaunchProfiling, @YES),
+                                     SENTRY_OPTION(enableTracing, @YES),
+                                     SENTRY_OPTION(tracesSampleRate, @1),
+                                     SENTRY_OPTION(profilesSampleRate, @1) }];
+    [options addEntriesFromDictionary:overrides];
+    return [self defaultOptionsWithOverrides:options];
+}
+
+- (SentryOptions *)defaultOptionsWithOverrides:(nullable NSDictionary<NSString *, id> *)overrides
+{
+    NSMutableDictionary<NSString *, id> *options = [NSMutableDictionary<NSString *, id>
+        dictionaryWithObject:@"https://username:password@sentry.io/1"
+                      forKey:@"dsn"];
+    [options addEntriesFromDictionary:overrides];
+    NSError *error;
+    SentryOptions *sentryOptions = [[SentryOptions alloc] initWithDict:options
+                                                      didFailWithError:&error];
+    XCTAssertNil(error);
+    return sentryOptions;
+}
+
+#    undef SENTRY_OPTION
+
+@end
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Tests/SentryProfilerTests/SentryProfilerSwiftTests.swift b/Tests/SentryProfilerTests/SentryProfilerSwiftTests.swift
index 7075e485735..adc4ad35e33 100644
--- a/Tests/SentryProfilerTests/SentryProfilerSwiftTests.swift
+++ b/Tests/SentryProfilerTests/SentryProfilerSwiftTests.swift
@@ -16,8 +16,6 @@ class SentryProfilerSwiftTests: XCTestCase {
         lazy var hub: SentryHub = {
             let hub = SentryHub(client: client, andScope: scope)
             hub.bindClient(client)
-            Dynamic(hub).tracesSampler.random = TestRandom(value: 1.0)
-            Dynamic(hub).profilesSampler.random = TestRandom(value: 0.5)
             return hub
         }()
         let scope = Scope()
@@ -37,7 +35,7 @@ class SentryProfilerSwiftTests: XCTestCase {
 #if !os(macOS)
         lazy var displayLinkWrapper = TestDisplayLinkWrapper(dateProvider: currentDateProvider)
         lazy var framesTracker = SentryFramesTracker(displayLinkWrapper: displayLinkWrapper, dateProvider: currentDateProvider, dispatchQueueWrapper: SentryDispatchQueueWrapper(), keepDelayedFramesDuration: 0)
-#endif
+#endif // !os(macOS)
 
         init() {
             SentryDependencyContainer.sharedInstance().dateProvider = currentDateProvider
@@ -52,6 +50,8 @@ class SentryProfilerSwiftTests: XCTestCase {
             SentryDependencyContainer.sharedInstance().dispatchFactory = dispatchFactory
             SentryDependencyContainer.sharedInstance().timerFactory = timeoutTimerFactory
             SentryDependencyContainer.sharedInstance().dispatchQueueWrapper = dispatchQueueWrapper
+            
+            SentryDependencyContainer.sharedInstance().random = TestRandom(value: 0.5)
 
             systemWrapper.overrides.cpuUsage = NSNumber(value: mockCPUUsage)
             systemWrapper.overrides.memoryFootprintBytes = mockMemoryFootprint
@@ -61,7 +61,7 @@ class SentryProfilerSwiftTests: XCTestCase {
             SentryDependencyContainer.sharedInstance().framesTracker = framesTracker
             framesTracker.start()
             displayLinkWrapper.call()
-#endif
+#endif // !os(macOS)
         }
 
         /// Advance the mock date provider, start a new transaction and return its handle.
@@ -95,9 +95,7 @@ class SentryProfilerSwiftTests: XCTestCase {
 #if !os(macOS)
         // SentryFramesTracker starts assuming a frame rate of 60 Hz and will only log an update if it changes, so the first value here needs to be different for it to register.
         let mockFrameRateChangesPerBatch: [FrameRate] = [.high, .low, .high, .low]
-#endif
 
-#if !os(macOS)
         // Absolute timestamps must be adjusted per span when asserting
         var expectedSlowFrames = [[String: Any]]()
         var expectedFrozenFrames = [[String: Any]]()
@@ -108,7 +106,7 @@ class SentryProfilerSwiftTests: XCTestCase {
             expectedFrozenFrames = [[String: Any]]()
             expectedFrameRateChanges = [[String: Any]]()
         }
-#endif
+#endif // !os(macOS)
 
         func gatherMockedMetrics(span: Span) throws {
             // clear out any errors that might've been set in previous calls
@@ -124,14 +122,14 @@ class SentryProfilerSwiftTests: XCTestCase {
                 systemWrapper.overrides.cpuEnergyUsage = NSNumber(value: systemWrapper.overrides.cpuEnergyUsage!.intValue + mockEnergyUsage.intValue)
             }
 
-    #if !os(macOS)
+#if !os(macOS)
             var shouldRecordFrameRateExpectation = true
-
+            
             func changeFrameRate(_ new: FrameRate) {
                 displayLinkWrapper.changeFrameRate(new)
                 shouldRecordFrameRateExpectation = true
             }
-
+            
             func renderGPUFrame(_ type: GPUFrame) {
                 switch type {
                 case .normal:
@@ -165,7 +163,7 @@ class SentryProfilerSwiftTests: XCTestCase {
                     ])
                 }
             }
-
+            
             /*
              * Mock a series of GPU frame renders of varying quality (normal/slow/frozen) and
              * refresh rate changes. The refresh rate changes ("|") happen at the same time as
@@ -198,7 +196,7 @@ class SentryProfilerSwiftTests: XCTestCase {
             renderGPUFrame(.slow)
             renderGPUFrame(.normal)
             renderGPUFrame(.frozen)
-    #endif
+#endif // !os(macOS)
 
             // mock errors gathering cpu usage and memory footprint and fire a callback for them to ensure they don't add more information to the payload
             systemWrapper.overrides.cpuUsageError = NSError(domain: "test-error", code: 0)
@@ -218,7 +216,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         var appStartDuration = 0.5
         lazy var appStartEnd = appStart.addingTimeInterval(appStartDuration)
 
-        #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#if !os(macOS)
         func getAppStartMeasurement(type: SentryAppStartType, preWarmed: Bool = false) -> SentryAppStartMeasurement {
             let runtimeInitDuration = 0.05
             let runtimeInit = appStart.addingTimeInterval(runtimeInitDuration)
@@ -231,7 +229,7 @@ class SentryProfilerSwiftTests: XCTestCase {
             return SentryAppStartMeasurement(type: type, isPreWarmed: preWarmed, appStartTimestamp: appStart, duration: appStartDuration, runtimeInitTimestamp: runtimeInit, moduleInitializationTimestamp: main,
                                              sdkStartTimestamp: appStart, didFinishLaunchingTimestamp: didFinishLaunching)
         }
-        #endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#endif // !os(macOS)
     }
 
     private var fixture: Fixture!
@@ -323,7 +321,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         spans.removeAll()
 #if !os(macOS)
         fixture.resetGPUExpectations()
-#endif
+#endif // !os(macOS)
 
         try createConcurrentSpansWithMetrics()
     }
@@ -380,7 +378,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         try performTest(transactionEnvironment: expectedEnvironment)
     }
 
-    #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#if !os(macOS)
     func testProfileWithTransactionContainingStartupSpansForColdStart() throws {
         try performTest(uikitParameters: UIKitParameters(launchType: .cold, prewarmed: false))
     }
@@ -392,7 +390,7 @@ class SentryProfilerSwiftTests: XCTestCase {
     func testProfileWithTransactionContainingStartupSpansForPrewarmedStart() throws {
         try performTest(uikitParameters: UIKitParameters(launchType: .cold, prewarmed: true))
     }
-#endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#endif // !os(macOS)
 
     func testProfilingDataContainsEnvironmentSetFromConfigureScope() throws {
         let expectedEnvironment = "test-environment"
@@ -434,7 +432,7 @@ class SentryProfilerSwiftTests: XCTestCase {
 
     func testStartTransaction_WhenProfilesSampleRateAndProfilesSamplerNil() throws {
         try assertProfilesSampler(expectedDecision: .no) { options in
-            options.profilesSampleRate = nil
+            options.profilesSampleRate = 0
             options.profilesSampler = { _ in return nil }
         }
     }
@@ -534,7 +532,7 @@ class SentryProfilerSwiftTests: XCTestCase {
         XCTAssertEqual(self.fixture.client?.captureEventWithScopeInvocations.count, 0)
     }
 
-#if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#if !os(macOS)
     /// based on ``SentryTracerTests.testFinish_WaitForAllChildren_StartTimeModified_NoTransactionCaptured``
     func testProfilerCleanedUpAfterTransactionDiscarded_WaitForAllChildren_StartTimeModified() throws {
         XCTAssertEqual(SentryProfiler.currentProfiledTracers(), UInt(0))
@@ -551,7 +549,8 @@ class SentryProfilerSwiftTests: XCTestCase {
         XCTAssertEqual(SentryProfiler.currentProfiledTracers(), UInt(0))
         XCTAssertEqual(self.fixture.client?.captureEventWithScopeInvocations.count, 0)
     }
-#endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#endif // !os(macOS)
+    
 }
 
 private extension SentryProfilerSwiftTests {
@@ -581,16 +580,16 @@ private extension SentryProfilerSwiftTests {
     }
 
     struct UIKitParameters {
-        #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
         var launchType: SentryAppStartType
         var prewarmed: Bool
-        #endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+#endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
     }
 
     func performTest(transactionEnvironment: String = kSentryDefaultEnvironment, shouldTimeOut: Bool = false, uikitParameters: UIKitParameters? = nil) throws {
         var testingAppLaunchSpans = false
-
-            #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+        
+#if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
         if let uikitParameters = uikitParameters {
             testingAppLaunchSpans = true
             let appStartMeasurement = fixture.getAppStartMeasurement(type: uikitParameters.launchType, preWarmed: uikitParameters.prewarmed)
@@ -637,7 +636,7 @@ private extension SentryProfilerSwiftTests {
         try assertMetricEntries(measurements: measurements, key: kSentryProfilerSerializationKeySlowFrameRenders, expectedEntries: fixture.expectedSlowFrames, transaction: transaction)
         try assertMetricEntries(measurements: measurements, key: kSentryProfilerSerializationKeyFrozenFrameRenders, expectedEntries: fixture.expectedFrozenFrames, transaction: transaction)
         try assertMetricEntries(measurements: measurements, key: kSentryProfilerSerializationKeyFrameRates, expectedEntries: fixture.expectedFrameRateChanges, transaction: transaction)
-#endif
+#endif // !os(macOS)
     }
 
     func sortedByTimestamps(_ entries: [[String: Any]]) -> [[String: Any]] {
@@ -724,7 +723,7 @@ private extension SentryProfilerSwiftTests {
         XCTAssertTrue(try XCTUnwrap(device["is_emulator"] as? Bool))
 #else
         XCTAssertFalse(try XCTUnwrap(device["is_emulator"] as? Bool))
-#endif
+#endif // targetEnvironment(simulator)
 
         let os = try XCTUnwrap(profile["os"] as? [String: Any?])
         XCTAssertNotNil(os)
@@ -830,7 +829,7 @@ private extension SentryProfilerSwiftTests {
     func assertProfilesSampler(expectedDecision: SentrySampleDecision, options: (Options) -> Void) throws {
         let fixtureOptions = fixture.options
         fixtureOptions.tracesSampleRate = 1.0
-        fixtureOptions.profilesSampleRate = nil
+        fixtureOptions.profilesSampleRate = 0
         fixtureOptions.profilesSampler = { _ in
             switch expectedDecision {
             case .undecided, .no:
@@ -843,10 +842,7 @@ private extension SentryProfilerSwiftTests {
             }
         }
         options(fixtureOptions)
-
-        let hub = fixture.hub
-        Dynamic(hub).tracesSampler.random = TestRandom(value: 1.0)
-
+        
         let span = try fixture.newTransaction()
         addMockSamples()
         fixture.currentDateProvider.advance(by: 5)
diff --git a/Tests/SentryProfilerTests/SentryProfilerTests.mm b/Tests/SentryProfilerTests/SentryProfilerTests.mm
index 30de6e3c2f3..ddeed62c428 100644
--- a/Tests/SentryProfilerTests/SentryProfilerTests.mm
+++ b/Tests/SentryProfilerTests/SentryProfilerTests.mm
@@ -262,4 +262,4 @@ - (void)testProfilerPayload
 
 @end
 
-#endif
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Tests/SentryTests/Helper/SentryFileManager+TestProperties.h b/Tests/SentryTests/Helper/SentryFileManager+Test.h
similarity index 72%
rename from Tests/SentryTests/Helper/SentryFileManager+TestProperties.h
rename to Tests/SentryTests/Helper/SentryFileManager+Test.h
index 093e846e821..eab8a37ec9f 100644
--- a/Tests/SentryTests/Helper/SentryFileManager+TestProperties.h
+++ b/Tests/SentryTests/Helper/SentryFileManager+Test.h
@@ -2,6 +2,9 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+SENTRY_EXTERN NSURL *launchProfileConfigFileURL(void);
+SENTRY_EXTERN NSURL *_Nullable sentryLaunchConfigFileURL;
+
 @interface
 SentryFileManager ()
 
diff --git a/Tests/SentryTests/Helper/SentryFileManagerTests.swift b/Tests/SentryTests/Helper/SentryFileManagerTests.swift
index 39fb13664a3..0489c8fe7b9 100644
--- a/Tests/SentryTests/Helper/SentryFileManagerTests.swift
+++ b/Tests/SentryTests/Helper/SentryFileManagerTests.swift
@@ -14,13 +14,13 @@ class SentryFileManagerTests: XCTestCase {
         let dispatchQueueWrapper: TestSentryDispatchQueueWrapper!
         
         let options: Options
-
+        
         let session = SentrySession(releaseName: "1.0.0", distinctId: "some-id")
         let sessionEnvelope: SentryEnvelope
-
+        
         let sessionUpdate: SentrySession
         let sessionUpdateEnvelope: SentryEnvelope
-
+        
         let expectedSessionUpdate: SentrySession
         
         // swiftlint:disable weak_delegate
@@ -32,23 +32,23 @@ class SentryFileManagerTests: XCTestCase {
         init() {
             currentDateProvider = TestCurrentDateProvider()
             dispatchQueueWrapper = TestSentryDispatchQueueWrapper()
-
+            
             eventIds = (0...(maxCacheItems + 10)).map { _ in SentryId() }
             
             options = Options()
             options.dsn = TestConstants.dsnAsString(username: "SentryFileManagerTests")
             
             sessionEnvelope = SentryEnvelope(session: session)
-
+            
             let sessionCopy = session.copy() as! SentrySession
             sessionCopy.incrementErrors()
             // We need to serialize in order to set the timestamp and the duration
             sessionUpdate = SentrySession(jsonObject: sessionCopy.serialize())!
-
+            
             let event = Event()
             let items = [SentryEnvelopeItem(session: sessionUpdate), SentryEnvelopeItem(event: event)]
             sessionUpdateEnvelope = SentryEnvelope(id: event.eventId, items: items)
-
+            
             let sessionUpdateCopy = sessionUpdate.copy() as! SentrySession
             // We need to serialize in order to set the timestamp and the duration
             expectedSessionUpdate = SentrySession(jsonObject: sessionUpdateCopy.serialize())!
@@ -70,19 +70,19 @@ class SentryFileManagerTests: XCTestCase {
             sut.setDelegate(delegate)
             return sut
         }
-
+        
     }
-
+    
     private var fixture: Fixture!
     private var sut: SentryFileManager!
-
+    
     override func setUp() {
         super.setUp()
         fixture = Fixture()
         SentryDependencyContainer.sharedInstance().dateProvider = fixture.currentDateProvider
-
+        
         sut = fixture.getSut()
-
+        
         sut.deleteAllEnvelopes()
         sut.deleteTimestampLastInForeground()
     }
@@ -102,10 +102,10 @@ class SentryFileManagerTests: XCTestCase {
         sut.store(TestConstants.envelope)
         sut.storeCurrentSession(SentrySession(releaseName: "1.0.0", distinctId: "some-id"))
         sut.storeTimestampLast(inForeground: Date())
-
+        
         _ = try! SentryFileManager(options: fixture.options, dispatchQueueWrapper: TestSentryDispatchQueueWrapper())
         let fileManager = try! SentryFileManager(options: fixture.options, dispatchQueueWrapper: TestSentryDispatchQueueWrapper())
-
+        
         XCTAssertEqual(1, fileManager.getAllEnvelopes().count)
         XCTAssertNotNil(fileManager.readCurrentSession())
         XCTAssertNotNil(fileManager.readTimestampLastInForeground())
@@ -122,7 +122,7 @@ class SentryFileManagerTests: XCTestCase {
     func testInitDoesntCreateEventsFolder() {
         assertEventFolderDoesntExist()
     }
-
+    
     func testStoreEnvelope() throws {
         let envelope = TestConstants.envelope
         sut.store(envelope)
@@ -135,13 +135,13 @@ class SentryFileManagerTests: XCTestCase {
         let actualData = envelopes[0].contents
         XCTAssertEqual(expectedData, actualData as Data)
     }
-
+    
     func testDeleteOldEnvelopes() throws {
         try givenOldEnvelopes()
-
+        
         sut = fixture.getSut()
         sut.deleteOldEnvelopeItems()
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 0)
     }
     
@@ -214,39 +214,39 @@ class SentryFileManagerTests: XCTestCase {
         sut.deleteOldEnvelopeItems()
         
         try givenOldEnvelopes()
-
+        
         sut.deleteOldEnvelopeItems()
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 0)
     }
-
+    
     func testDontDeleteYoungEnvelopes() throws {
         let envelope = TestConstants.envelope
         let path = sut.store(envelope)
-
+        
         let timeIntervalSince1970 = fixture.currentDateProvider.date().timeIntervalSince1970 - (90 * 24 * 60 * 60)
         let date = Date(timeIntervalSince1970: timeIntervalSince1970)
         try FileManager.default.setAttributes([FileAttributeKey.creationDate: date], ofItemAtPath: path)
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
-
+        
         sut = fixture.getSut()
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
     }
-
+    
     func testDontDeleteYoungEnvelopesFromOldEnvelopesFolder() throws {
         let envelope = TestConstants.envelope
         sut.store(envelope)
-
+        
         let timeIntervalSince1970 = fixture.currentDateProvider.date().timeIntervalSince1970 - (90 * 24 * 60 * 60)
         let date = Date(timeIntervalSince1970: timeIntervalSince1970)
         try FileManager.default.setAttributes([FileAttributeKey.creationDate: date], ofItemAtPath: sut.envelopesPath)
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
-
+        
         sut = fixture.getSut()
-
+        
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
     }
     
@@ -254,7 +254,7 @@ class SentryFileManagerTests: XCTestCase {
         try givenOldEnvelopes()
         
         fixture.dispatchQueueWrapper.dispatchAsyncExecutesBlock = false
-
+        
         // Initialize sut in extra function so ARC deallocates it
         func getSut() {
             _ = fixture.getSut()
@@ -265,7 +265,7 @@ class SentryFileManagerTests: XCTestCase {
         
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
     }
-
+    
     func testCreateDirDoesNotThrow() throws {
         try SentryFileManager.createDirectory(atPath: "a")
     }
@@ -276,12 +276,12 @@ class SentryFileManagerTests: XCTestCase {
         sut.removeFile(atPath: "x")
         XCTAssertFalse(logOutput.loggedMessages.contains(where: { $0.contains("[error]") }))
     }
-
+    
     func testDefaultMaxEnvelopes() {
         for _ in 0...(fixture.maxCacheItems + 1) {
             sut.store(TestConstants.envelope)
         }
-
+        
         let events = sut.getAllEnvelopes()
         XCTAssertEqual(fixture.maxCacheItems, events.count)
     }
@@ -302,7 +302,7 @@ class SentryFileManagerTests: XCTestCase {
         let expected: [SentryDataCategory] = [.error, .attachment, .session, .error]
         XCTAssertEqual(expected, fixture.delegate.envelopeItemsDeleted.invocations)
     }
-
+    
     func testDefaultMaxEnvelopesConcurrent() {
         let maxCacheItems = 1
         let sut = fixture.getSut(maxCacheItems: UInt(maxCacheItems))
@@ -323,7 +323,7 @@ class SentryFileManagerTests: XCTestCase {
         queue.activate()
         
         wait(for: [envelopeStoredExpectation], timeout: 10)
-
+        
         let events = sut.getAllEnvelopes()
         XCTAssertEqual(maxCacheItems, events.count)
     }
@@ -337,7 +337,7 @@ class SentryFileManagerTests: XCTestCase {
         let events = sut.getAllEnvelopes()
         XCTAssertEqual(maxCacheItems, UInt(events.count))
     }
-
+    
     func testMigrateSessionInit_SessionUpdateIsLast() {
         sut.store(fixture.sessionEnvelope)
         // just some other session
@@ -346,22 +346,22 @@ class SentryFileManagerTests: XCTestCase {
             sut.store(TestConstants.envelope)
         }
         sut.store(fixture.sessionUpdateEnvelope)
-
+        
         assertSessionInitMoved(sut.getAllEnvelopes().last!)
         assertSessionEnvelopesStored(count: 2)
     }
-
+    
     func testMigrateSessionInit_SessionUpdateIsSecond() {
         sut.store(fixture.sessionEnvelope)
         sut.store(fixture.sessionUpdateEnvelope)
         for _ in 0...(fixture.maxCacheItems - 2) {
             sut.store(TestConstants.envelope)
         }
-
+        
         assertSessionInitMoved(sut.getAllEnvelopes().first!)
         assertSessionEnvelopesStored(count: 1)
     }
-
+    
     func testMigrateSessionInit_IsInMiddle() {
         sut.store(fixture.sessionEnvelope)
         for _ in 0...10 {
@@ -371,7 +371,7 @@ class SentryFileManagerTests: XCTestCase {
         for _ in 0...18 {
             sut.store(TestConstants.envelope)
         }
-
+        
         assertSessionInitMoved(sut.getAllEnvelopes()[10])
         assertSessionEnvelopesStored(count: 1)
     }
@@ -387,20 +387,20 @@ class SentryFileManagerTests: XCTestCase {
         for _ in 0...16 {
             sut.store(TestConstants.envelope)
         }
-
+        
         assertSessionInitMoved(sut.getAllEnvelopes()[10])
         assertSessionInitNotMoved(sut.getAllEnvelopes()[11])
         assertSessionInitNotMoved(sut.getAllEnvelopes()[12])
         assertSessionEnvelopesStored(count: 3)
     }
-
+    
     func testMigrateSessionInit_NoOtherSessionUpdate() {
         sut.store(fixture.sessionEnvelope)
         sut.store(fixture.sessionUpdateEnvelope)
         for _ in 0...(fixture.maxCacheItems - 1) {
             sut.store(TestConstants.envelope)
         }
-
+        
         assertSessionEnvelopesStored(count: 0)
     }
     
@@ -418,7 +418,7 @@ class SentryFileManagerTests: XCTestCase {
         try! fileManager.createDirectory(atPath: envelopePath, withIntermediateDirectories: false, attributes: nil)
         
         sut.store(fixture.sessionUpdateEnvelope)
-
+        
         assertSessionInitMoved(sut.getAllEnvelopes().last!)
     }
     
@@ -428,18 +428,18 @@ class SentryFileManagerTests: XCTestCase {
         for _ in 0...(fixture.maxCacheItems - 2) {
             sut.store(TestConstants.envelope)
         }
-
+        
         XCTAssertEqual(0, fixture.delegate.envelopeItemsDeleted.count)
     }
-
+    
     func testGetAllEnvelopesAreSortedByDateAscending() {
         givenMaximumEnvelopes()
-
+        
         let envelopes = sut.getAllEnvelopes()
-
+        
         // Envelopes are sorted ascending by date and only the latest amount of maxCacheItems are kept
         let expectedEventIds = Array(fixture.eventIds[11..<fixture.eventIds.count])
-
+        
         XCTAssertEqual(fixture.maxCacheItems, envelopes.count)
         for i in 0..<fixture.maxCacheItems {
             let envelope = SentrySerialization.envelope(with: envelopes[i].contents)
@@ -447,26 +447,26 @@ class SentryFileManagerTests: XCTestCase {
             XCTAssertEqual(expectedEventIds[i], actualEventId)
         }
     }
-
+    
     func testGetOldestEnvelope() {
         givenMaximumEnvelopes()
-
+        
         let actualEnvelope = SentrySerialization.envelope(with: sut.getOldestEnvelope()?.contents ?? Data())
-
+        
         XCTAssertEqual(fixture.eventIds[11], actualEnvelope?.header.eventId)
     }
-
+    
     func testGetOldestEnvelope_WhenNoEnvelopes() {
         XCTAssertNil(sut.getOldestEnvelope())
     }
-
+    
     func testGetOldestEnvelope_WithGarbageInEnvelopesFolder() {
         givenGarbageInEnvelopesFolder()
-
+        
         let actualEnvelope = SentrySerialization.envelope(with: sut.getOldestEnvelope()?.contents ?? Data())
         XCTAssertNil(actualEnvelope)
     }
-
+    
     func testStoreAndReadCurrentSession() {
         let expectedSession = SentrySession(releaseName: "1.0.0", distinctId: "some-id")
         sut.storeCurrentSession(expectedSession)
@@ -481,7 +481,7 @@ class SentryFileManagerTests: XCTestCase {
         let actualSession = sut.readCrashedSession()
         XCTAssertTrue(expectedSession.distinctId == actualSession?.distinctId)
     }
-
+    
     func testStoreDeleteCurrentSession() {
         sut.storeCurrentSession(SentrySession(releaseName: "1.0.0", distinctId: "some-id"))
         sut.deleteCurrentSession()
@@ -495,14 +495,14 @@ class SentryFileManagerTests: XCTestCase {
         let actualSession = sut.readCrashedSession()
         XCTAssertNil(actualSession)
     }
-
+    
     func testStoreAndReadTimestampLastInForeground() {
         let expectedTimestamp = TestCurrentDateProvider().date()
         sut.storeTimestampLast(inForeground: expectedTimestamp)
         let actualTimestamp = sut.readTimestampLastInForeground()
         XCTAssertEqual(actualTimestamp, expectedTimestamp)
     }
-
+    
     func testStoreDeleteTimestampLastInForeground() {
         sut.storeTimestampLast(inForeground: Date())
         sut.deleteTimestampLastInForeground()
@@ -513,7 +513,7 @@ class SentryFileManagerTests: XCTestCase {
     func testGetAllStoredEventsAndEnvelopes() {
         sut.store(TestConstants.envelope)
         sut.store(TestConstants.envelope)
-
+        
         XCTAssertEqual(2, sut.getAllEnvelopes().count)
     }
     
@@ -523,7 +523,7 @@ class SentryFileManagerTests: XCTestCase {
         sut.storeCurrentSession(SentrySession(releaseName: "1.0.1", distinctId: "some-id"))
         
         sut.deleteAllFolders()
-
+        
         XCTAssertEqual(0, sut.getAllEnvelopes().count)
         XCTAssertNil(sut.readCurrentSession())
         assertEventFolderDoesntExist()
@@ -533,7 +533,7 @@ class SentryFileManagerTests: XCTestCase {
         sut.store(TestConstants.envelope)
         
         sut.deleteAllEnvelopes()
-
+        
         XCTAssertEqual(0, sut.getAllEnvelopes().count)
     }
     
@@ -561,12 +561,12 @@ class SentryFileManagerTests: XCTestCase {
         sut.deleteAppState()
         XCTAssertNil(sut.readAppState())
     }
-
+    
     func testDeletePreviousAppState() {
         sut.store(TestData.appState)
         sut.moveAppStateToPreviousAppState()
         sut.deleteAppState()
-
+        
         XCTAssertNil(sut.readAppState())
         XCTAssertNil(sut.readPreviousAppState())
     }
@@ -601,58 +601,58 @@ class SentryFileManagerTests: XCTestCase {
         sut.deleteAppState()
         XCTAssertNotNil(sut.readAppState())
     }
-
+    
     func testMoveAppStateAndReadPreviousAppState() {
         sut.store(TestData.appState)
         sut.moveAppStateToPreviousAppState()
-
+        
         let actual = sut.readPreviousAppState()
         XCTAssertEqual(TestData.appState, actual)
     }
-
+    
     func testMoveAppStateWhenPreviousAppStateAlreadyExists() {
         sut.store(TestData.appState)
         sut.moveAppStateToPreviousAppState()
-
+        
         let newAppState = SentryAppState(releaseName: "2.0.0", osVersion: "14.4.1", vendorId: "12345678-1234-1234-1234-12344567890AB", isDebugging: false, systemBootTimestamp: Date(timeIntervalSince1970: 10))
         sut.store(newAppState)
         sut.moveAppStateToPreviousAppState()
-
+        
         let actual = sut.readPreviousAppState()
         XCTAssertEqual(newAppState, actual)
     }
-
+    
     func testStoreAndReadTimezoneOffset() {
         sut.storeTimezoneOffset(7_200)
         XCTAssertEqual(sut.readTimezoneOffset(), 7_200)
     }
-
+    
     func testtestStoreAndReadNegativeTimezoneOffset() {
         sut.storeTimezoneOffset(-1_000)
         XCTAssertEqual(sut.readTimezoneOffset(), -1_000)
     }
-
+    
     func testStoreDeleteTimezoneOffset() {
         sut.storeTimezoneOffset(7_200)
         sut.deleteTimezoneOffset()
         XCTAssertNil(sut.readTimezoneOffset())
     }
-
+    
     func testStore_WhenFileImmutable_TimezoneOffsetIsNotOverwritten() {
         sut.storeTimezoneOffset(7_200)
-
+        
         setImmutableForTimezoneOffset(immutable: true)
-
+        
         sut.storeTimezoneOffset(9_600)
-
+        
         XCTAssertEqual(sut.readTimezoneOffset(), 7_200)
     }
-
+    
     func testStoreDeleteTimezoneOffset_WhenFileLocked_DontCrash() throws {
         sut.storeTimezoneOffset(7_200)
-
+        
         setImmutableForTimezoneOffset(immutable: true)
-
+        
         sut.deleteTimezoneOffset()
         XCTAssertNotNil(sut.readTimezoneOffset())
     }
@@ -663,20 +663,20 @@ class SentryFileManagerTests: XCTestCase {
         
         XCTAssertTrue(sut.sentryPath.hasPrefix("/var/tmp/io.sentry"))
     }
-
-    #if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
-
+    
+#if os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
+    
     func testReadPreviousBreadcrumbs() {
         let observer = SentryWatchdogTerminationScopeObserver(maxBreadcrumbs: 2, fileManager: sut)
-
+        
         for count in 0..<3 {
             let crumb = TestData.crumb
             crumb.message = "\(count)"
             let serializedBreadcrumb = crumb.serialize()
-
+            
             observer.addSerializedBreadcrumb(serializedBreadcrumb)
         }
-
+        
         sut.moveBreadcrumbsToPreviousBreadcrumbs()
         let result = sut.readPreviousBreadcrumbs()
         XCTAssertEqual(result.count, 3)
@@ -684,18 +684,18 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual((result[1] as! NSDictionary)["message"] as! String, "1")
         XCTAssertEqual((result[2] as! NSDictionary)["message"] as! String, "2")
     }
-
+    
     func testReadPreviousBreadcrumbsCorrectOrderWhenFileTwoHasMoreCrumbs() {
         let observer = SentryWatchdogTerminationScopeObserver(maxBreadcrumbs: 2, fileManager: sut)
-
+        
         for count in 0..<5 {
             let crumb = TestData.crumb
             crumb.message = "\(count)"
             let serializedBreadcrumb = crumb.serialize()
-
+            
             observer.addSerializedBreadcrumb(serializedBreadcrumb)
         }
-
+        
         sut.moveBreadcrumbsToPreviousBreadcrumbs()
         let result = sut.readPreviousBreadcrumbs()
         XCTAssertEqual(result.count, 3)
@@ -703,15 +703,135 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual((result[1] as! NSDictionary)["message"] as! String, "3")
         XCTAssertEqual((result[2] as! NSDictionary)["message"] as! String, "4")
     }
-
+    
 #endif // os(iOS) || os(tvOS) || targetEnvironment(macCatalyst)
-
+    
     func testReadGarbageTimezoneOffset() throws {
         try "garbage".write(to: URL(fileURLWithPath: sut.timezoneOffsetFilePath), atomically: true, encoding: .utf8)
         XCTAssertNil(sut.readTimezoneOffset())
     }
+}
+
+#if os(iOS) || os(macOS) || targetEnvironment(macCatalyst)
+// MARK: App Launch profiling tests
+extension SentryFileManagerTests {
+    // if app launch profiling was configured to take place
+    func testAppLaunchProfileConfigFileExists_fileExists() throws {
+        try ensureAppLaunchProfileConfig()
+        expect(appLaunchProfileConfigFileExists()) == true
+    }
+    
+    // if app launch profiling was not configured to take place
+    func testAppLaunchProfileConfigFileExists_fileDoesNotExist() throws {
+        try ensureAppLaunchProfileConfig(exists: false)
+        expect(appLaunchProfileConfigFileExists()) == false
+    }
+    
+    func testAppLaunchProfileConfiguration() throws {
+        let expectedTracesSampleRate = 0.12
+        let expectedProfilesSampleRate = 0.34
+        try ensureAppLaunchProfileConfig(tracesSampleRate: expectedTracesSampleRate, profilesSampleRate: expectedProfilesSampleRate)
+        let config = appLaunchProfileConfiguration()
+        let actualTracesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyTracesSampleRate]).doubleValue
+        let actualProfilesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyProfilesSampleRate]).doubleValue
+        expect(actualTracesSampleRate) == expectedTracesSampleRate
+        expect(actualProfilesSampleRate) == expectedProfilesSampleRate
+    }
+    
+    // if a file isn't present when we expect it to be, like if there was an issue when we went to write it to disk
+    func testAppLaunchProfileConfiguration_noConfigurationExists() throws {
+        try ensureAppLaunchProfileConfig(exists: false)
+        expect(appLaunchProfileConfiguration()) == nil
+    }
+    
+    func testWriteAppLaunchProfilingConfigFile_noCurrentFileExists() throws {
+        try ensureAppLaunchProfileConfig(exists: false)
+        
+        let expectedTracesSampleRate = 0.12
+        let expectedProfilesSampleRate = 0.34
+        writeAppLaunchProfilingConfigFile([
+            kSentryLaunchProfileConfigKeyTracesSampleRate: expectedTracesSampleRate,
+            kSentryLaunchProfileConfigKeyProfilesSampleRate: expectedProfilesSampleRate
+        ])
+        
+        let config = NSDictionary(contentsOf: launchProfileConfigFileURL())
+        
+        let actualTracesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyTracesSampleRate] as? NSNumber).doubleValue
+        let actualProfilesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyProfilesSampleRate] as? NSNumber).doubleValue
+        expect(actualTracesSampleRate) == expectedTracesSampleRate
+        expect(actualProfilesSampleRate) == expectedProfilesSampleRate
+    }
+    
+    // if a file is still present in the primary location, like if a crash occurred before it could be removed, or an error occurred when trying to remove it or move it to the backup location, make sure we overwrite it
+    func testWriteAppLaunchProfilingConfigFile_fileAlreadyExists() throws {
+        try ensureAppLaunchProfileConfig(exists: true, tracesSampleRate: 0.75, profilesSampleRate: 0.75)
+        
+        let expectedTracesSampleRate = 0.12
+        let expectedProfilesSampleRate = 0.34
+        writeAppLaunchProfilingConfigFile([
+            kSentryLaunchProfileConfigKeyTracesSampleRate: expectedTracesSampleRate,
+            kSentryLaunchProfileConfigKeyProfilesSampleRate: expectedProfilesSampleRate
+        ])
+        
+        let config = NSDictionary(contentsOf: launchProfileConfigFileURL())
+        
+        let actualTracesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyTracesSampleRate] as? NSNumber).doubleValue
+        let actualProfilesSampleRate = try XCTUnwrap(config?[kSentryLaunchProfileConfigKeyProfilesSampleRate] as? NSNumber).doubleValue
+        expect(actualTracesSampleRate) == expectedTracesSampleRate
+        expect(actualProfilesSampleRate) == expectedProfilesSampleRate
+    }
+    
+    func testRemoveAppLaunchProfilingConfigFile() throws {
+        try ensureAppLaunchProfileConfig(exists: true)
+        expect(NSDictionary(contentsOf: launchProfileConfigFileURL())) != nil
+        removeAppLaunchProfilingConfigFile()
+        expect(NSDictionary(contentsOf: launchProfileConfigFileURL())) == nil
+    }
+    
+    // if there's not a file when we expect one, just make sure we don't crash
+    func testRemoveAppLaunchProfilingConfigFile_noFileExists() throws {
+        try ensureAppLaunchProfileConfig(exists: false)
+        expect(NSDictionary(contentsOf: launchProfileConfigFileURL())) == nil
+        removeAppLaunchProfilingConfigFile()
+        expect(NSDictionary(contentsOf: launchProfileConfigFileURL())) == nil
+    }
+    
+    func testCheckForLaunchProfilingConfigFile_URLDoesNotExist() {
+        // cause the dispatch_once to initialize the internal value
+        let originalURL = launchProfileConfigFileURL()
+
+        // set to nil to simulate exceptional environments
+        sentryLaunchConfigFileURL = nil
+
+        // make sure we return a default-off value and also don't crash the call to access()
+        expect(appLaunchProfileConfigFileExists()) == false
+        
+        // set the original value back so other tests don't crash
+        sentryLaunchConfigFileURL = (originalURL as NSURL)
+    }
+}
+
+// MARK: Private profiling tests
+private extension SentryFileManagerTests {
+    func ensureAppLaunchProfileConfig(exists: Bool = true, tracesSampleRate: Double = 1, profilesSampleRate: Double = 1) throws {
+        let url = launchProfileConfigFileURL()
+        
+        if exists {
+            let dict = [kSentryLaunchProfileConfigKeyTracesSampleRate: tracesSampleRate, kSentryLaunchProfileConfigKeyProfilesSampleRate: profilesSampleRate]
+            try (dict as NSDictionary).write(to: url)
+        } else {
+            let fm = FileManager.default
+            if fm.fileExists(atPath: url.path) {
+                try fm.removeItem(at: url)
+            }
+        }
+    }
+}
+#endif // os(iOS) || os(macOS) || targetEnvironment(macCatalyst)
 
-    private func givenMaximumEnvelopes() {
+// MARK: Private
+private extension SentryFileManagerTests {
+    func givenMaximumEnvelopes() {
         fixture.eventIds.forEach { id in
             let envelope = SentryEnvelope(id: id, singleItem: SentryEnvelopeItem(event: Event()))
 
@@ -720,7 +840,7 @@ class SentryFileManagerTests: XCTestCase {
         }
     }
 
-    private func givenGarbageInEnvelopesFolder() {
+    func givenGarbageInEnvelopesFolder() {
         do {
             try "garbage".write(to: URL(fileURLWithPath: "\(sut.envelopesPath)/garbage.json"), atomically: true, encoding: .utf8)
         } catch {
@@ -728,7 +848,7 @@ class SentryFileManagerTests: XCTestCase {
         }
     }
     
-    private func givenOldEnvelopes() throws {
+    func givenOldEnvelopes() throws {
         let envelope = TestConstants.envelope
         let path = sut.store(envelope)
 
@@ -739,7 +859,7 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual(sut.getAllEnvelopes().count, 1)
     }
 
-    private func storeEvent() {
+    func storeEvent() {
         do {
             // Store a fake event to the events folder
             try FileManager.default.createDirectory(atPath: sut.eventsPath, withIntermediateDirectories: true, attributes: nil)
@@ -749,7 +869,7 @@ class SentryFileManagerTests: XCTestCase {
         }
     }
     
-    private func setImmutableForAppState(immutable: Bool) {
+    func setImmutableForAppState(immutable: Bool) {
         let appStateFilePath = Dynamic(sut).appStateFilePath.asString ?? ""
         let fileManager = FileManager.default
         
@@ -764,7 +884,7 @@ class SentryFileManagerTests: XCTestCase {
         }
     }
 
-    private func setImmutableForTimezoneOffset(immutable: Bool) {
+    func setImmutableForTimezoneOffset(immutable: Bool) {
         let timezoneOffsetFilePath = Dynamic(sut).timezoneOffsetFilePath.asString ?? ""
         let fileManager = FileManager.default
 
@@ -779,12 +899,12 @@ class SentryFileManagerTests: XCTestCase {
         }
     }
 
-    private func assertEventFolderDoesntExist() {
+    func assertEventFolderDoesntExist() {
         XCTAssertFalse(FileManager.default.fileExists(atPath: sut.eventsPath),
                         "Folder for events should be deleted on init: \(sut.eventsPath)")
     }
 
-    private func assertSessionInitMoved(_ actualSessionFileContents: SentryFileContents) {
+    func assertSessionInitMoved(_ actualSessionFileContents: SentryFileContents) {
         let actualSessionEnvelope = SentrySerialization.envelope(with: actualSessionFileContents.contents)
         XCTAssertEqual(2, actualSessionEnvelope?.items.count)
 
@@ -794,7 +914,7 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual(fixture.expectedSessionUpdate, actualSession)
     }
     
-    private func assertSessionInitNotMoved(_ actualSessionFileContents: SentryFileContents) {
+    func assertSessionInitNotMoved(_ actualSessionFileContents: SentryFileContents) {
         let actualSessionEnvelope = SentrySerialization.envelope(with: actualSessionFileContents.contents)
         XCTAssertEqual(2, actualSessionEnvelope?.items.count)
 
@@ -804,7 +924,7 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual(fixture.sessionUpdate, actualSession)
     }
 
-    private func assertSessionEnvelopesStored(count: Int) {
+    func assertSessionEnvelopesStored(count: Int) {
         let fileContentsWithSession = sut.getAllEnvelopes().filter { envelopeFileContents in
             let envelope = SentrySerialization.envelope(with: envelopeFileContents.contents)
             return !(envelope?.items.filter { item in item.header.type == SentryEnvelopeItemTypeSession }.isEmpty ?? false)
@@ -813,16 +933,16 @@ class SentryFileManagerTests: XCTestCase {
         XCTAssertEqual(count, fileContentsWithSession.count)
     }
     
-    private func assertValidAppStateStored() {
+    func assertValidAppStateStored() {
         let actual = sut.readAppState()
         XCTAssertEqual(TestData.appState, actual)
     }
 
-    private func advanceTime(bySeconds: TimeInterval) {
+    func advanceTime(bySeconds: TimeInterval) {
         fixture.currentDateProvider.setDate(date: fixture.currentDateProvider.date().addingTimeInterval(bySeconds))
     }
     
-    private class AppStateWithFaultySerialization: SentryAppState {
+    class AppStateWithFaultySerialization: SentryAppState {
         override func serialize() -> [String: Any] {
             return ["app": self]
         }
diff --git a/Tests/SentryTests/SentryHubTests.swift b/Tests/SentryTests/SentryHubTests.swift
index f5bfcf2821e..69cfd78389f 100644
--- a/Tests/SentryTests/SentryHubTests.swift
+++ b/Tests/SentryTests/SentryHubTests.swift
@@ -39,6 +39,7 @@ class SentryHubTests: XCTestCase {
             fileManager = try! SentryFileManager(options: options, dispatchQueueWrapper: TestSentryDispatchQueueWrapper())
             
             SentryDependencyContainer.sharedInstance().dateProvider = currentDateProvider
+            SentryDependencyContainer.sharedInstance().random = random
             
             crashedSession = SentrySession(releaseName: "1.0.0", distinctId: "")
             crashedSession.endCrashed(withTimestamp: currentDateProvider.date())
@@ -341,8 +342,6 @@ class SentryHubTests: XCTestCase {
         }
         
         let hub = fixture.getSut()
-        Dynamic(hub).sampler.random = fixture.random
-        
         let span = hub.startTransaction(name: fixture.transactionName, operation: fixture.transactionOperation)
         XCTAssertEqual(span.sampled, .no)
     }
@@ -810,6 +809,20 @@ class SentryHubTests: XCTestCase {
     }
 #endif
     
+    func testStartTransaction_WhenSamplerNil_NotSampled() {
+        assertSampler(expected: .no) { options in
+            options.tracesSampleRate = 0.49
+            options.tracesSampler = { _ in return nil }
+        }
+    }
+    
+    func testStartTransaction_WhenSamplerNil_Sampled() {
+        assertSampler(expected: .yes) { options in
+            options.tracesSampleRate = 0.50
+            options.tracesSampler = { _ in return nil }
+        }
+    }
+    
     private func addBreadcrumbThroughConfigureScope(_ hub: SentryHub) {
         hub.configureScope({ scope in
             scope.addBreadcrumb(self.fixture.crumb)
@@ -1038,8 +1051,6 @@ class SentryHubTests: XCTestCase {
         options(fixture.options)
         
         let hub = fixture.getSut()
-        Dynamic(hub).tracesSampler.random = fixture.random
-        
         let span = hub.startTransaction(name: fixture.transactionName, operation: fixture.transactionOperation)
         
         XCTAssertEqual(expected, span.sampled)
diff --git a/Tests/SentryTests/SentryLaunchProfiling+Tests.h b/Tests/SentryTests/SentryLaunchProfiling+Tests.h
new file mode 100644
index 00000000000..c4f1ba31d6c
--- /dev/null
+++ b/Tests/SentryTests/SentryLaunchProfiling+Tests.h
@@ -0,0 +1,27 @@
+#import "SentryDefines.h"
+#import "SentryLaunchProfiling.h"
+
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+
+@class SentrySamplerDecision;
+@class SentryOptions;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef struct {
+    BOOL shouldProfile;
+    SentrySamplerDecision *_Nullable tracesDecision;
+    SentrySamplerDecision *_Nullable profilesDecision;
+} SentryLaunchProfileConfig;
+
+SENTRY_EXTERN SentryLaunchProfileConfig shouldProfileNextLaunch(SentryOptions *options);
+
+SENTRY_EXTERN NSString *const kSentryLaunchProfileConfigKeyTracesSampleRate;
+SENTRY_EXTERN NSString *const kSentryLaunchProfileConfigKeyProfilesSampleRate;
+
+SENTRY_EXTERN SentryTransactionContext *context(NSNumber *tracesRate);
+SENTRY_EXTERN SentryTracerConfiguration *config(NSNumber *profilesRate);
+
+NS_ASSUME_NONNULL_END
+
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
diff --git a/Tests/SentryTests/SentryOptionsTest.m b/Tests/SentryTests/SentryOptionsTest.m
index e9025655764..ea71527b1e9 100644
--- a/Tests/SentryTests/SentryOptionsTest.m
+++ b/Tests/SentryTests/SentryOptionsTest.m
@@ -429,7 +429,7 @@ - (void)testSampleRate_SetToNil
 {
     SentryOptions *options = [[SentryOptions alloc] init];
     options.sampleRate = nil;
-    XCTAssertNil(options.sampleRate);
+    XCTAssertEqual(options.sampleRate.doubleValue, 0);
 }
 
 - (void)testSampleRateLowerBound
@@ -859,7 +859,7 @@ - (void)testChanging_tracesSampler_afterSetting_enableTracing
     options.enableTracing = YES;
     options.tracesSampler = sampler;
     XCTAssertTrue(options.enableTracing);
-    options.tracesSampleRate = nil;
+    options.tracesSampleRate = @0;
     XCTAssertTrue(options.enableTracing);
 
     options.enableTracing = NO;
@@ -878,8 +878,7 @@ - (void)testTracesSampleRate
 - (void)testDefaultTracesSampleRate
 {
     SentryOptions *options = [self getValidOptions:@{}];
-
-    XCTAssertNil(options.tracesSampleRate);
+    XCTAssertEqual(options.tracesSampleRate.doubleValue, 0);
 }
 
 - (void)testTracesSampleRate_SetToNil
@@ -887,6 +886,7 @@ - (void)testTracesSampleRate_SetToNil
     SentryOptions *options = [[SentryOptions alloc] init];
     options.tracesSampleRate = nil;
     XCTAssertNil(options.tracesSampleRate);
+    XCTAssertEqual(options.tracesSampleRate.doubleValue, 0);
 }
 
 - (void)testTracesSampleRateLowerBound
@@ -902,7 +902,7 @@ - (void)testTracesSampleRateLowerBound
 
     NSNumber *tooLow = @-0.01;
     options.tracesSampleRate = tooLow;
-    XCTAssertNil(options.tracesSampleRate);
+    XCTAssertEqual(options.tracesSampleRate.doubleValue, 0);
 }
 
 - (void)testTracesSampleRateUpperBound
@@ -918,7 +918,7 @@ - (void)testTracesSampleRateUpperBound
 
     NSNumber *tooLow = @1.01;
     options.tracesSampleRate = tooLow;
-    XCTAssertNil(options.tracesSampleRate);
+    XCTAssertEqual(options.tracesSampleRate.doubleValue, 0);
 }
 
 - (double)tracesSamplerCallback:(NSDictionary *)context
@@ -999,7 +999,7 @@ - (void)testDefaultProfilesSampleRate
 {
     SentryOptions *options = [self getValidOptions:@{}];
 
-    XCTAssertNil(options.profilesSampleRate);
+    XCTAssertEqual(options.profilesSampleRate.doubleValue, 0);
 }
 
 - (void)testProfilesSampleRate_SetToNil
@@ -1007,6 +1007,7 @@ - (void)testProfilesSampleRate_SetToNil
     SentryOptions *options = [[SentryOptions alloc] init];
     options.profilesSampleRate = nil;
     XCTAssertNil(options.profilesSampleRate);
+    XCTAssertEqual(options.profilesSampleRate.doubleValue, 0);
 }
 
 - (void)testProfilesSampleRateLowerBound
@@ -1022,7 +1023,7 @@ - (void)testProfilesSampleRateLowerBound
 
     NSNumber *tooLow = @-0.01;
     options.profilesSampleRate = tooLow;
-    XCTAssertNil(options.profilesSampleRate);
+    XCTAssertEqual(options.profilesSampleRate.doubleValue, 0);
 }
 
 - (void)testProfilesSampleRateUpperBound
@@ -1038,7 +1039,7 @@ - (void)testProfilesSampleRateUpperBound
 
     NSNumber *tooLow = @1.01;
     options.profilesSampleRate = tooLow;
-    XCTAssertNil(options.profilesSampleRate);
+    XCTAssertEqual(options.profilesSampleRate.doubleValue, 0);
 }
 
 - (void)testIsProfilingEnabled_NothingSet_IsDisabled
@@ -1191,6 +1192,14 @@ - (void)testInitialScope
     XCTAssertIdentical(initialScope, options.initialScope);
 }
 
+#if SENTRY_TARGET_PROFILING_SUPPORTED
+- (void)testEnableAppLaunchProfilingDefaultValue
+{
+    SentryOptions *options = [self getValidOptions:@{}];
+    XCTAssertFalse(options.enableAppLaunchProfiling);
+}
+#endif // SENTRY_TARGET_PROFILING_SUPPORTED
+
 - (SentryOptions *)getValidOptions:(NSDictionary<NSString *, id> *)dict
 {
     NSError *error = nil;
diff --git a/Tests/SentryTests/SentrySDK+Tests.h b/Tests/SentryTests/SentrySDK+Tests.h
index 159ab4e7841..2dab5e5c388 100644
--- a/Tests/SentryTests/SentrySDK+Tests.h
+++ b/Tests/SentryTests/SentrySDK+Tests.h
@@ -1,7 +1,13 @@
+#import "SentryDefines.h"
+#import "SentrySDK.h"
+
+@class SentryEnvelope;
+@class SentryHub;
+
 NS_ASSUME_NONNULL_BEGIN
 
 @interface
-SentrySDK (Tests)
+SentrySDK ()
 
 + (void)setCurrentHub:(nullable SentryHub *)hub;
 
diff --git a/Tests/SentryTests/SentryTests-Bridging-Header.h b/Tests/SentryTests/SentryTests-Bridging-Header.h
index acbe3676eaa..26bdb95b5cd 100644
--- a/Tests/SentryTests/SentryTests-Bridging-Header.h
+++ b/Tests/SentryTests/SentryTests-Bridging-Header.h
@@ -107,7 +107,7 @@
 #import "SentryEvent+Private.h"
 #import "SentryFileContents.h"
 #import "SentryFileIOTrackingIntegration.h"
-#import "SentryFileManager+TestProperties.h"
+#import "SentryFileManager+Test.h"
 #import "SentryFileManager.h"
 #import "SentryFormatter.h"
 #import "SentryFrame.h"
@@ -125,6 +125,7 @@
 #import "SentryInstallation+Test.h"
 #import "SentryInstallation.h"
 #import "SentryInternalNotificationNames.h"
+#import "SentryLaunchProfiling+Tests.h"
 #import "SentryLevelMapper.h"
 #import "SentryLog+TestInit.h"
 #import "SentryLog.h"
diff --git a/Tests/SentryTests/Transaction/SentryTracerObjCTests.m b/Tests/SentryTests/Transaction/SentryTracerObjCTests.m
index 16fe6673002..3ddf1741033 100644
--- a/Tests/SentryTests/Transaction/SentryTracerObjCTests.m
+++ b/Tests/SentryTests/Transaction/SentryTracerObjCTests.m
@@ -10,7 +10,6 @@
 
 #if SENTRY_TARGET_PROFILING_SUPPORTED
 #    import "SentryProfiler.h"
-#    import "SentryProfilesSampler.h"
 #endif // SENTRY_TARGET_PROFILING_SUPPORTED
 
 @interface SentryTracerObjCTests : XCTestCase
diff --git a/develop-docs/README.md b/develop-docs/README.md
index b0548c42412..43967e649fd 100644
--- a/develop-docs/README.md
+++ b/develop-docs/README.md
@@ -111,3 +111,19 @@ This feature is experimental and is currently not compatible with SPM.
 ## Logging
 
 We have a set of macros for debugging at various levels defined in SentryLog.h. These are not async-safe; to log from special places like crash handlers, see SentryCrashLogger.h; see the headerdocs in that header for how to work with those logging macros. There are also separate macros in SentryProfilingLogging.hpp specifically for the profiler; these are completely compiled out of release builds due to https://github.com/getsentry/sentry-cocoa/issues/3336.
+
+## Profiling
+
+The profiler runs on a dedicated thread, and on a predefined interval will enumerate all other threads and gather the backtrace on each non-idle thread. 
+
+The information is stored in deduplicated frame and stack indexed lookups for memory and transmission efficiency. These are maintained in `SentryProfilerState`.
+
+If enabled and sampled in (controlled by `SentryOptions.profilesSampleRate` or `SentryOptions.profilesSampler`), the profiler will start along with a trace, and the profile information is sliced to the start and end of each transaction and sent with them an envelope attachments. 
+
+The profiler will automatically time out if it is not stopped within 30 seconds, and also stops automatically if the app is sent to the background.
+
+There's only ever one profiler instance running at a time, but instances that have timed out will be kept in memory until all traces that ran concurrently with it have finished and serialized to envelopes. The associations between profiler instances and traces are maintained in `SentryProfiledTracerConcurrency`. 
+
+App launches can be automatically profiled if configured with `SentryOptions.enableAppLaunchProfiling`. If enabled, when `SentrySDK.startWithOptions` is called, `SentryLaunchProfiling.configureLaunchProfiling` will get a sample rate for traces and profiles with their respective options, and store those rates in a file to be read on the next launch. On each launch, `SentryLaunchProfiling.startLaunchProfile` checks for the presence of that file is used to decide whether to start an app launch profiled trace, and afterwards retrieves those rates to initialize a `SentryTransactionContext` and `SentryTracerConfiguration`, and provides them to a new `SentryTracer` instance, which is what actually starts the profiler. There is no hub at this time; also in the call to `SentrySDK.startWithOptions`, any current profiled launch trace is attempted to be finished, and the hub that exists by that time is provided to the `SentryTracer` instance via `SentryLaunchProfiling.stopLaunchProfile` so that when it needs to transmit the transaction envelope, the infrastructure is in place to do so.
+
+In testing and debug environments, when a profile payload is serialized for transmission, the dictionary will also be written to a file in application support that can be retrieved by a sample app. This helps with UI tests that want to verify the contents of a profile after some app interaction. See `iOS-Swift.ProfilingViewController.viewLastProfile`  and `iOS-SwiftUITests.ProfilingUITests`.