feat: add logging_config-based remote logging control and SDK version gating

- Derive isRemoteLoggingEnabled from log_level presence in logging_config
  (empty object = disabled, has log_level = enabled)
- Add OtelSdkSupport utility for testable SDK version checks (API 26+)
- Gate all Otel initialization (crash, ANR, remote logging) on both
  SDK support and backend config
- Rename OneSignalCrashLogInit to OneSignalOtelInit to reflect full scope
- Simplify OneSignalCrashHandlerFactory with require() instead of no-op
- Add crash test button in demo app SecondaryActivity
- Fix Compose compiler plugin compatibility with AGP 8.8.2
- Add flow chart documentation for init sequence

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: AR Abdul Azeez

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/core/internal/backend/IParamsBackendService.kt

@@ -58,4 +58,5 @@ internal class FCMParamsObject(
 
 internal class RemoteLoggingParamsObject(
     val logLevel: com.onesignal.debug.LogLevel? = null,
+    val isEnabled: Boolean = logLevel != null && logLevel != com.onesignal.debug.LogLevel.NONE,
 )

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/core/internal/config/ConfigModel.kt

@@ -454,4 +454,14 @@ class RemoteLoggingConfigModel(
         set(value) {
             setOptEnumProperty(::logLevel.name, value)
         }
+
+    /**
+     * Whether remote logging is enabled.
+     * Set by backend config hydration — true when the server sends a valid log_level, false otherwise.
+     */
+    var isEnabled: Boolean
+        get() = getBooleanProperty(::isEnabled.name) { false }
+        set(value) {
+            setBooleanProperty(::isEnabled.name, value)
+        }
 }

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/core/internal/config/impl/ConfigModelStoreListener.kt

@@ -104,6 +104,7 @@ internal class ConfigModelStoreListener(
                     params.influenceParams.isUnattributedEnabled?.let { config.influenceParams.isUnattributedEnabled = it }
 
                     params.remoteLoggingParams.logLevel?.let { config.remoteLoggingParams.logLevel = it }
+                    config.remoteLoggingParams.isEnabled = params.remoteLoggingParams.isEnabled
 
                     _configModelStore.replace(config, ModelChangeTags.HYDRATE)
                     success = true

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/crash/OneSignalCrashHandlerFactory.kt

@@ -1,51 +1,38 @@
 package com.onesignal.debug.internal.crash
 
 import android.content.Context
-import android.os.Build
 import com.onesignal.debug.internal.logging.Logging
 import com.onesignal.debug.internal.logging.otel.android.createAndroidOtelPlatformProvider
 import com.onesignal.otel.IOtelCrashHandler
 import com.onesignal.otel.IOtelLogger
 import com.onesignal.otel.OtelFactory
 
 /**
- * Factory for creating crash handlers with SDK version checks.
- * For SDK < 26, returns a no-op implementation.
- * For SDK >= 26, returns the Otel-based crash handler.
+ * Factory for creating Otel-based crash handlers.
+ * Callers must verify [OtelSdkSupport.isSupported] before calling [createCrashHandler].
  *
  * Uses minimal dependencies - only Context and logger.
  * Platform provider uses OtelIdResolver internally which reads from SharedPreferences.
  */
 internal object OneSignalCrashHandlerFactory {
     /**
-     * Creates a crash handler appropriate for the current SDK version.
-     * This should be called as early as possible, before any other initialization.
+     * Creates an Otel crash handler. Must only be called on supported devices
+     * (SDK >= [OtelSdkSupport.MIN_SDK_VERSION]).
      *
      * @param context Android context for creating platform provider
      * @param logger Logger instance (can be shared with other components)
+     * @throws IllegalArgumentException if called on an unsupported SDK
      */
     fun createCrashHandler(
         context: Context,
         logger: IOtelLogger,
     ): IOtelCrashHandler {
-        // Otel requires SDK 26+, use no-op for older versions
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-            Logging.info("OneSignal: Creating no-op crash handler (SDK ${Build.VERSION.SDK_INT} < 26)")
-            return NoOpCrashHandler()
+        require(OtelSdkSupport.isSupported) {
+            "createCrashHandler called on unsupported SDK (< ${OtelSdkSupport.MIN_SDK_VERSION})"
         }
 
-        Logging.info("OneSignal: Creating Otel crash handler (SDK ${Build.VERSION.SDK_INT} >= 26)")
-        // Create platform provider - uses OtelIdResolver internally
+        Logging.info("OneSignal: Creating Otel crash handler (SDK >= ${OtelSdkSupport.MIN_SDK_VERSION})")
         val platformProvider = createAndroidOtelPlatformProvider(context)
         return OtelFactory.createCrashHandler(platformProvider, logger)
     }
 }
-
-/**
- * No-op crash handler for SDK < 26.
- */
-private class NoOpCrashHandler : IOtelCrashHandler {
-    override fun initialize() {
-        Logging.info("OneSignal: No-op crash handler initialized (SDK < 26, Otel not supported)")
-    }
-}

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/crash/OtelAnrDetector.kt

@@ -23,7 +23,7 @@ import java.util.concurrent.atomic.AtomicLong
  * It creates its own crash reporter to save ANR reports.
  */
 internal class OtelAnrDetector(
-    private val openTelemetryCrash: IOtelOpenTelemetryCrash,
+    openTelemetryCrash: IOtelOpenTelemetryCrash,
     private val logger: IOtelLogger,
     private val anrThresholdMs: Long = AnrConstants.DEFAULT_ANR_THRESHOLD_MS,
     private val checkIntervalMs: Long = AnrConstants.DEFAULT_CHECK_INTERVAL_MS,

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/crash/OtelSdkSupport.kt

@@ -0,0 +1,27 @@
+package com.onesignal.debug.internal.crash
+
+import android.os.Build
+
+/**
+ * Centralizes the SDK version requirement for Otel-based features
+ * (crash reporting, ANR detection, remote log shipping).
+ *
+ * [isSupported] is writable internally so that unit tests can override
+ * the device-level gate without Robolectric @Config gymnastics.
+ */
+internal object OtelSdkSupport {
+    /** Otel libraries require Android O (API 26) or above. */
+    const val MIN_SDK_VERSION = Build.VERSION_CODES.O // 26
+
+    /**
+     * Whether the current device meets the minimum SDK requirement.
+     * Production code should treat this as read-only; tests may flip it via [reset]/direct set.
+     */
+    var isSupported: Boolean = Build.VERSION.SDK_INT >= MIN_SDK_VERSION
+        internal set
+
+    /** Restores the runtime-detected value — call in test teardown. */
+    fun reset() {
+        isSupported = Build.VERSION.SDK_INT >= MIN_SDK_VERSION
+    }
+}

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/logging/otel/android/OtelIdResolver.kt

@@ -190,6 +190,23 @@ internal class OtelIdResolver(
         }
     }
 
+    /**
+     * Resolves whether remote logging is enabled from cached ConfigModelStore.
+     * Enabled is derived from the presence of a valid logLevel:
+     * - "logging_config": {} → no logLevel → disabled (not on allowlist)
+     * - "logging_config": {"log_level": "ERROR"} → has logLevel → enabled (on allowlist)
+     * Returns false if not found, empty, or on error (disabled by default on first launch).
+     */
+    @Suppress("TooGenericExceptionCaught", "SwallowedException")
+    fun resolveRemoteLoggingEnabled(): Boolean {
+        return try {
+            val logLevel = resolveRemoteLogLevel()
+            logLevel != null && logLevel != com.onesignal.debug.LogLevel.NONE
+        } catch (e: Exception) {
+            false
+        }
+    }
+
     /**
      * Resolves remote log level from cached ConfigModelStore.
      * Returns null if not found or if there's an error.

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/debug/internal/logging/otel/android/OtelPlatformProvider.kt

@@ -34,7 +34,7 @@ internal class OtelPlatformProvider(
     override val appVersion: String = config.appVersion
     private val context: Context? = config.context
     private val getIsInForeground: (() -> Boolean?)? = config.getIsInForeground
-    private val idResolver = OtelIdResolver(context)
+    private val idResolver = OneSignalIdResolver(context)
 
     // Top-level attributes (static, calculated once)
     override suspend fun getInstallId(): String = idResolver.resolveInstallId()
@@ -121,28 +121,23 @@ internal class OtelPlatformProvider(
     override val minFileAgeForReadMillis: Long = 5_000
 
     // Remote logging configuration
+    override val isRemoteLoggingEnabled: Boolean by lazy {
+        idResolver.resolveRemoteLoggingEnabled()
+    }
+
     /**
      * The minimum log level to send remotely as a string.
-     * - If remote config log level is populated and valid: use that level
-     * - If remote config is null or unavailable: default to "ERROR" (always log errors)
-     * - If remote config is explicitly NONE: return "NONE" (no logs including errors)
+     * - "logging_config": {"log_level": "ERROR"} → returns "ERROR" (enabled, on allowlist)
+     * - "logging_config": {} → returns null (disabled, not on allowlist)
+     * - No config cached yet → returns null (first launch)
      */
     @Suppress("TooGenericExceptionCaught", "SwallowedException")
     override val remoteLogLevel: String? by lazy {
         try {
             val configLevel = idResolver.resolveRemoteLogLevel()
-            when {
-                // Remote config is populated and working well - use whatever is sent from there
-                configLevel != null && configLevel != com.onesignal.debug.LogLevel.NONE -> configLevel.name
-                // Explicitly NONE means no logging (including errors)
-                configLevel == com.onesignal.debug.LogLevel.NONE -> "NONE"
-                // Remote config not available - default to ERROR (always log errors)
-                else -> "ERROR"
-            }
+            configLevel?.name
         } catch (e: Exception) {
-            // If there's an error accessing config, default to ERROR (always log errors)
-            // Exception is intentionally swallowed to avoid recursion in logging
-            "ERROR"
+            null
         }
     }
 

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/internal/OneSignalImp.kt

@@ -207,20 +207,20 @@ internal class OneSignalImp(
     }
 
     private fun initEssentials(context: Context) {
-        // Create OneSignalCrashLogInit instance once - it manages platform provider lifecycle
-        // Platform provider is created lazily and reused for both crash handler and logging
-        val crashLogInit = OneSignalCrashLogInit(context)
+        // Create OneSignalOtelInit instance once - it manages platform provider lifecycle
+        // Platform provider is created lazily and reused for crash handler, ANR detector, and logging
+        val otelInit = OneSignalOtelInit(context)
 
         // Crash handler needs to be one of the first things we setup,
         // otherwise we'll not report some crashes, resulting in a false sense
         // of stability.
         // Initialize crash handler early, before any other services that might crash.
         // This is decoupled from getService to ensure fast initialization.
-        crashLogInit.initializeCrashHandler()
+        otelInit.initializeCrashHandler()
 
         // Initialize Otel logging integration - reuses the same platform provider created in initializeCrashHandler
         // No service dependencies required, reads directly from SharedPreferences
-        crashLogInit.initializeOtelLogging()
+        otelInit.initializeOtelLogging()
 
         PreferenceStoreFix.ensureNoObfuscatedPrefStore(context)
 

…signal/internal/OneSignalCrashLogInit.kt …/onesignal/internal/OneSignalOtelInit.ktOneSignalSDK/onesignal/core/src/main/java/com/onesignal/internal/OneSignalCrashLogInit.kt renamed to OneSignalSDK/onesignal/core/src/main/java/com/onesignal/internal/OneSignalOtelInit.kt OneSignalSDK/onesignal/core/src/main/java/com/onesignal/internal/OneSignalCrashLogInit.kt renamed to OneSignalSDK/onesignal/core/src/main/java/com/onesignal/internal/OneSignalOtelInit.kt

@@ -3,6 +3,8 @@ package com.onesignal.internal
 import android.content.Context
 import com.onesignal.common.threading.suspendifyOnIO
 import com.onesignal.debug.LogLevel
+import com.onesignal.debug.internal.crash.OneSignalCrashHandlerFactory
+import com.onesignal.debug.internal.crash.OtelSdkSupport
 import com.onesignal.debug.internal.crash.createAnrDetector
 import com.onesignal.debug.internal.logging.Logging
 import com.onesignal.debug.internal.logging.otel.android.AndroidOtelLogger
@@ -14,12 +16,12 @@ import com.onesignal.otel.OtelFactory
 import com.onesignal.otel.crash.IOtelAnrDetector
 
 /**
- * Helper class for OneSignal initialization tasks.
- * Extracted from OneSignalImp to reduce class size and improve maintainability.
+ * Initializes all Otel-based observability features: crash reporting, ANR detection,
+ * and remote log shipping.
  *
- * Creates and reuses a single OtelPlatformProvider instance for both crash handler and logging.
+ * Creates and reuses a single OtelPlatformProvider instance across all features.
  */
-internal class OneSignalCrashLogInit(
+internal class OneSignalOtelInit(
     private val context: Context,
 ) {
     // Platform provider - created once and reused for both crash handler and logging
@@ -29,21 +31,27 @@ internal class OneSignalCrashLogInit(
 
     @Suppress("TooGenericExceptionCaught")
     fun initializeCrashHandler() {
+        if (!OtelSdkSupport.isSupported) {
+            Logging.info("OneSignal: Device SDK < ${OtelSdkSupport.MIN_SDK_VERSION}, Otel not supported — skipping crash handler and ANR detector")
+            return
+        }
+        if (!platformProvider.isRemoteLoggingEnabled) {
+            Logging.info("OneSignal: Remote logging disabled (not yet enabled via config), skipping crash handler and ANR detector")
+            return
+        }
+
         try {
             Logging.info("OneSignal: Initializing crash handler early...")
-            Logging.info("OneSignal: Creating crash handler with minimal dependencies...")
 
-            // Create crash handler directly (non-blocking, doesn't require services upfront)
+            // Use factory which handles SDK version checks (no-op for SDK < 26)
             val logger = AndroidOtelLogger()
-            val crashHandler: IOtelCrashHandler = OtelFactory.createCrashHandler(platformProvider, logger)
+            val crashHandler: IOtelCrashHandler = OneSignalCrashHandlerFactory.createCrashHandler(context, logger)
 
             Logging.info("OneSignal: Crash handler created, initializing...")
             crashHandler.initialize()
 
-            // Log crash storage location for debugging
             Logging.info("OneSignal: ✅ Crash handler initialized successfully and ready to capture crashes")
             Logging.info("OneSignal: 📁 Crash logs will be stored at: ${platformProvider.crashStoragePath}")
-            Logging.info("OneSignal: 💡 To view crash logs, use: adb shell run-as ${platformProvider.appPackageId} ls -la ${platformProvider.crashStoragePath}")
 
             // Initialize ANR detector (standalone, monitors main thread for ANRs)
             try {
@@ -57,17 +65,23 @@ internal class OneSignalCrashLogInit(
                 anrDetector.start()
                 Logging.info("OneSignal: ✅ ANR detector initialized and started")
             } catch (e: Exception) {
-                // If ANR detector initialization fails, log it but don't crash
                 Logging.error("OneSignal: Failed to initialize ANR detector: ${e.message}", e)
             }
         } catch (e: Exception) {
-            // If crash handler initialization fails, log it but don't crash
             Logging.error("OneSignal: Failed to initialize crash handler: ${e.message}", e)
         }
     }
 
     @Suppress("TooGenericExceptionCaught")
     fun initializeOtelLogging() {
+        if (!OtelSdkSupport.isSupported) {
+            Logging.info("OneSignal: Device SDK < ${OtelSdkSupport.MIN_SDK_VERSION}, Otel not supported — skipping Otel logging")
+            return
+        }
+        if (!platformProvider.isRemoteLoggingEnabled) {
+            Logging.info("OneSignal: Remote logging disabled, skipping Otel logging integration")
+            return
+        }
         // Initialize Otel logging asynchronously to avoid blocking initialization
         // Remote logging is not critical for crashes, so it's safe to do this in the background
         // Uses OtelIdResolver internally which reads directly from SharedPreferences