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)

// Share of users that keep full data
const DETAIL_SAMPLE_RATE = 20;
// Share of detail users that get recorded
const REPLAY_SAMPLE_RATE = 10;

// Map a bucket key stably onto 0-99 so every event with the same key lands in the same bucket
function bucketOf(key) {
  let hash = 0;
  for (let i = 0; i < key.length; i++) {
    hash = (hash * 31 + key.charCodeAt(i)) | 0;
  }
  return Math.abs(hash) % 100;
}

// Implemented by your code: signed-in user ID first, otherwise your own
// anonymous ID (generated once and stored in localStorage)
const bucketKey = getCurrentUserId() || getOrCreateAnonId();
const inDetailBucket = bucketOf(bucketKey) < DETAIL_SAMPLE_RATE;

flashcatRum.init({
  applicationId: "<APPLICATION_ID>",
  clientToken: "<CLIENT_TOKEN>",
  sessionSampleRate: 100, // Collect every session so no error is dropped
  // Replay alignment: draw REPLAY_SAMPLE_RATE within detail users, never
  // record the rest (omit this line if you do not use Session Replay)
  sessionReplaySampleRate: inDetailBucket ? REPLAY_SAMPLE_RATE : 0,
  trackResources: true,
  trackUserInteractions: true,
  trackLongTasks: true,
  beforeSend: (event) => {
    // The exact same decision as before init(), so the two cannot drift
    const isDetail = bucketOf(getCurrentUserId() || getOrCreateAnonId()) < DETAIL_SAMPLE_RATE;

    // Stamp every surviving event so the session declares whether it is a full
    // picture or an errors-only summary
    event.context = {
      ...event.context,
      rum_sampling: isDetail ? "full" : "errors_only",
    };

    // View events cannot be dismissed; let them through explicitly to avoid an SDK warning
    if (event.type === "view") return true;

    // Always keep error events
    if (event.type === "error") return true;

    // Always keep failed requests
    if (event.type === "resource") {
      const statusCode = event.resource.status_code;
      if (statusCode === 0 || statusCode >= 400) return true;
    }

    // Everything else is kept only for users that win the draw
    return isDetail;
  },
});