Understanding RUM sampling: mechanism, rules, and best practices

val prefs = getSharedPreferences("rum_config", Context.MODE_PRIVATE)

// 1. Initialize immediately with the locally cached value; never block SDK startup
val sampleRate = prefs.getFloat("session_sample_rate", 20f)

val rumConfig = RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(sampleRate)
    .build()
Rum.enable(rumConfig)

// 2. Fetch the latest value asynchronously and cache it; takes effect on next cold start
CoroutineScope(Dispatchers.IO).launch {
    runCatching { fetchRumConfig() } // request your own config service
        .onSuccess { config ->
            prefs.edit()
                .putFloat("session_sample_rate", config.sessionSampleRate)
                .apply()
        } // on fetch failure, keep using the cached value; collection is unaffected
}

let defaults = UserDefaults.standard

// 1. Initialize immediately with the locally cached value; never block SDK startup
let sampleRate = defaults.object(forKey: "rumSessionSampleRate") as? Float ?? 20

var rumConfig = RUM.Configuration(applicationID: "<RUM_APPLICATION_ID>")
rumConfig.sessionSampleRate = sampleRate
RUM.enable(with: rumConfig)

// 2. Fetch the latest value asynchronously and cache it; takes effect on next cold start
URLSession.shared.dataTask(with: configURL) { data, _, _ in
    guard let data,
          let config = try? JSONDecoder().decode(RumRemoteConfig.self, from: data)
    else { return } // on fetch failure, keep using the cached value; collection is unaffected
    defaults.set(config.sessionSampleRate, forKey: "rumSessionSampleRate")
}.resume()

// When a new config arrives, only record the pending value — don't rebuild immediately
func onConfigFetched(_ latest: RumRemoteConfig) {
    defaults.set(latest.sessionSampleRate, forKey: "rumSessionSampleRate")
    pendingSampleRate = latest.sessionSampleRate != currentSampleRate
        ? latest.sessionSampleRate : nil
}

// Rebuild at a quiet moment, such as the app returning to the foreground
NotificationCenter.default.addObserver(
    forName: UIApplication.willEnterForegroundNotification, object: nil, queue: .main
) { _ in
    guard let newRate = pendingSampleRate else { return }
    pendingSampleRate = nil

    Datadog.stopInstance() // stop the current instance
    Datadog.initialize(with: coreConfiguration, trackingConsent: .granted)
    var rumConfig = RUM.Configuration(applicationID: "<RUM_APPLICATION_ID>")
    rumConfig.sessionSampleRate = newRate
    RUM.enable(with: rumConfig) // also re-enable every other product you use (Logs, Trace, etc.)
    currentSampleRate = newRate
}

fun decideSampling(user: User, config: RumRemoteConfig): Boolean {
    // Short-circuit rules, highest priority first
    if (config.incidentMode) return true            // incident investigation mode: collect everything
    if (user.isInternal || user.isBeta) return true // internal/canary users: always sample
    if (user.isVip) return true                     // key users: always sample
    if (prefs.getBoolean("rum_had_error", false)) return true // hit an error last time: always sample

    // Base rule: deterministic hash bucketing by userId
    return hash(user.id + config.salt) % 100 < config.sampleRate
}

val sampled = decideSampling(currentUser, cachedConfig)

val rumConfig = RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(if (sampled) 100f else 0f)
    .build()
Rum.enable(rumConfig)

func decideSampling(user: User, config: RumRemoteConfig) -> Bool {
    // Short-circuit rules, highest priority first
    if config.incidentMode { return true }            // incident investigation mode: collect everything
    if user.isInternal || user.isBeta { return true } // internal/canary users: always sample
    if user.isVip { return true }                     // key users: always sample
    if UserDefaults.standard.bool(forKey: "rumHadError") { return true } // hit an error last time: always sample

    // Base rule: deterministic hash bucketing by userId
    return hash(user.id + config.salt) % 100 < config.sampleRate
}

let sampled = decideSampling(user: currentUser, config: cachedConfig)

var rumConfig = RUM.Configuration(applicationID: "<RUM_APPLICATION_ID>")
rumConfig.sessionSampleRate = sampled ? 100 : 0
RUM.enable(with: rumConfig)