feat(push): add X-Klaviyo-Sdk-Features header to push-token-register (MAGE-765) (#506)

Atharva8168 · claude · web-flow · commit da28ad9b37e1 · 2026-07-10T14:05:10.000-04:00
* feat(push): add X-Klaviyo-Sdk-Features header to push-token-register (MAGE-765) Reports when a host has explicitly disabled automatic push token forwarding while automatic push tracking is on, so the backend can track opt-out adoption (MAGE-766). Scoped to PushTokenApiRequest only; omitted entirely when tracking is off or forwarding is left at its default-on state, since only the opt-out case needs reporting. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * feat(push): always send both SDK feature flags in push-token header (MAGE-765) Previously the X-Klaviyo-Sdk-Features header was omitted unless automatic push tracking was on and forwarding was disabled, carrying only the forwarding key. Now it's always attached with both auto_push_tracking and auto_push_token_forwarding so all four flag combinations are visible for analysis, not just the opt-out case. auto_push_token_forwarding now mirrors the disable flag directly (1 unless explicitly disabled), independent of the tracking flag. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * feat(push): only include SDK feature flags whose manifest key is set (MAGE-765) Previously both auto_push_tracking and auto_push_token_forwarding were always present in X-Klaviyo-Sdk-Features, falling back to a default value when the host hadn't set the corresponding manifest key. Now each attribute is included only if its manifest key is actually declared, so the header reflects what the host explicitly configured rather than an assumed default. Adds Config.hasManifestKey(key) (mirroring getManifestBoolean/Int) to distinguish "key absent" from "key present and false", which getManifestBoolean's single default-value return couldn't do. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * fix(core): resolve duplicate DISABLE_AUTOMATIC_TOKEN_FORWARDING after merge The merge from feat/auto-push-tracking (PR #503) landed a second declaration of this constant without a git conflict, since both additions fell in non-overlapping diff hunks. Keeps PR #503's PUSH_PREFIX-based definition, which is also the one Klaviyo.kt actually uses to gate automatic push token registration; our header logic already references the constant by name, so no other change is needed. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> * refactor(core): extract scoped SdkFeatures catalog for X-Klaviyo-Sdk-Features (MAGE-765) Replaces the inline header-building in PushTokenApiRequest with a reusable, scoped feature catalog in core, mirroring the iOS design (klaviyo-swift-sdk#640) for cross-platform parity. - SdkFeatureScope enumerates the request surfaces a feature is reported on; SdkFeatureKey is a central catalog pairing each feature's wire name with its manifest key, scope, and raw->reported value mapping. - SdkFeatures.headerValue(scope) serializes only in-scope features whose manifest key is present, so a feature can never leak onto a request outside its scope. Adding a future (e.g. profile) feature header is a new key + scope, reusing the same serialization. Pure refactor: the emitted header is byte-identical for every manifest combination. Existing PushTokenApiRequestTest/EventApiRequestTest pass unchanged as the regression guard; SdkFeaturesTest covers the catalog. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
diff --git a/sdk/analytics/src/main/java/com/klaviyo/analytics/networking/requests/PushTokenApiRequest.kt b/sdk/analytics/src/main/java/com/klaviyo/analytics/networking/requests/PushTokenApiRequest.kt
@@ -3,6 +3,8 @@ package com.klaviyo.analytics.networking.requests
 import com.klaviyo.analytics.model.Profile
 import com.klaviyo.core.DeviceProperties
 import com.klaviyo.core.Registry
+import com.klaviyo.core.SdkFeatureScope
+import com.klaviyo.core.SdkFeatures
 import org.json.JSONObject
 
 /**
@@ -35,6 +37,11 @@ internal class PushTokenApiRequest(
         const val BG_UNAVAILABLE = "DENIED"
     }
 
+    init {
+        SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+            ?.let { headers[SdkFeatures.HEADER_NAME] = it }
+    }
+
     override val type: String = "Push Token"
 
     /**
diff --git a/sdk/analytics/src/test/java/com/klaviyo/analytics/networking/requests/EventApiRequestTest.kt b/sdk/analytics/src/test/java/com/klaviyo/analytics/networking/requests/EventApiRequestTest.kt
@@ -4,6 +4,7 @@ import com.klaviyo.analytics.Klaviyo
 import com.klaviyo.analytics.model.Event
 import com.klaviyo.analytics.model.EventKey
 import com.klaviyo.analytics.model.EventMetric
+import com.klaviyo.core.Constants
 import com.klaviyo.fixtures.mockDeviceProperties
 import com.klaviyo.fixtures.unmockDeviceProperties
 import io.mockk.every
@@ -14,6 +15,7 @@ import io.mockk.unmockkStatic
 import java.util.UUID
 import org.json.JSONObject
 import org.junit.After
+import org.junit.Assert.assertNull
 import org.junit.Before
 import org.junit.Test
 
@@ -233,4 +235,14 @@ internal class EventApiRequestTest : BaseApiRequestTest<EventApiRequest>() {
 
         compareJson(JSONObject(expectJson), JSONObject(request.requestBody!!))
     }
+
+    @Test
+    fun `Does not include the SDK features header even when the flags that would trigger it on PushTokenApiRequest are set`() {
+        every { mockConfig.hasManifestKey(Constants.AUTOMATIC_PUSH_TRACKING) } returns true
+        every { mockConfig.hasManifestKey(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING) } returns true
+        every { mockConfig.getManifestBoolean(Constants.AUTOMATIC_PUSH_TRACKING, false) } returns true
+        every { mockConfig.getManifestBoolean(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING, false) } returns true
+        val request = EventApiRequest(stubEvent, stubProfile)
+        assertNull(request.headers["X-Klaviyo-Sdk-Features"])
+    }
 }
diff --git a/sdk/analytics/src/test/java/com/klaviyo/analytics/networking/requests/PushTokenApiRequestTest.kt b/sdk/analytics/src/test/java/com/klaviyo/analytics/networking/requests/PushTokenApiRequestTest.kt
@@ -1,9 +1,11 @@
 package com.klaviyo.analytics.networking.requests
 
+import com.klaviyo.core.Constants
 import io.mockk.every
 import org.json.JSONObject
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
 import org.junit.Test
 
 internal class PushTokenApiRequestTest : BaseApiRequestTest<PushTokenApiRequest>() {
@@ -94,4 +96,51 @@ internal class PushTokenApiRequestTest : BaseApiRequestTest<PushTokenApiRequest>
         val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
         compareJson(JSONObject(expectJson), JSONObject(request.requestBody!!))
     }
+
+    @Test
+    fun `Does not include SDK features header when neither manifest key is present`() {
+        val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
+        assertNull(request.headers["X-Klaviyo-Sdk-Features"])
+    }
+
+    @Test
+    fun `SDK features header includes only auto_push_tracking when only that key is present`() {
+        every { mockConfig.hasManifestKey(Constants.AUTOMATIC_PUSH_TRACKING) } returns true
+        every { mockConfig.getManifestBoolean(Constants.AUTOMATIC_PUSH_TRACKING, false) } returns true
+        val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
+        assertEquals("auto_push_tracking=1;", request.headers["X-Klaviyo-Sdk-Features"])
+    }
+
+    @Test
+    fun `SDK features header includes only auto_push_token_forwarding when only that key is present`() {
+        every { mockConfig.hasManifestKey(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING) } returns true
+        every { mockConfig.getManifestBoolean(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING, false) } returns true
+        val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
+        assertEquals("auto_push_token_forwarding=0;", request.headers["X-Klaviyo-Sdk-Features"])
+    }
+
+    @Test
+    fun `SDK features header includes both attributes when both keys present and forwarding left at its default`() {
+        every { mockConfig.hasManifestKey(Constants.AUTOMATIC_PUSH_TRACKING) } returns true
+        every { mockConfig.hasManifestKey(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING) } returns true
+        every { mockConfig.getManifestBoolean(Constants.AUTOMATIC_PUSH_TRACKING, false) } returns true
+        val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
+        assertEquals(
+            "auto_push_tracking=1; auto_push_token_forwarding=1;",
+            request.headers["X-Klaviyo-Sdk-Features"]
+        )
+    }
+
+    @Test
+    fun `SDK features header includes both attributes when both keys present and forwarding explicitly disabled`() {
+        every { mockConfig.hasManifestKey(Constants.AUTOMATIC_PUSH_TRACKING) } returns true
+        every { mockConfig.hasManifestKey(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING) } returns true
+        every { mockConfig.getManifestBoolean(Constants.AUTOMATIC_PUSH_TRACKING, false) } returns true
+        every { mockConfig.getManifestBoolean(Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING, false) } returns true
+        val request = PushTokenApiRequest(PUSH_TOKEN, stubProfile)
+        assertEquals(
+            "auto_push_tracking=1; auto_push_token_forwarding=0;",
+            request.headers["X-Klaviyo-Sdk-Features"]
+        )
+    }
 }
diff --git a/sdk/core/src/main/java/com/klaviyo/core/SdkFeatures.kt b/sdk/core/src/main/java/com/klaviyo/core/SdkFeatures.kt
@@ -0,0 +1,71 @@
+package com.klaviyo.core
+
+/**
+ * The request surface a feature is reported on. Each request carrying the `X-Klaviyo-Sdk-Features`
+ * header reports only the features in its scope, so unrelated domains never share a request.
+ */
+enum class SdkFeatureScope {
+    PUSH_TOKEN_REGISTRATION
+}
+
+/**
+ * Central catalog of reportable SDK features. Each entry pairs its wire name (serialized into the
+ * header) with the manifest key it reads, its [scope], and how the raw manifest value maps to the
+ * reported value. Adding a feature — including one reported on a different request — is a new entry
+ * here; a feature is never serialized outside its [scope].
+ */
+enum class SdkFeatureKey(
+    val wireName: String,
+    val manifestKey: String,
+    val scope: SdkFeatureScope,
+    val reportedValue: (manifestValue: Boolean) -> Boolean = { it }
+) {
+    AUTO_PUSH_TRACKING(
+        wireName = "auto_push_tracking",
+        manifestKey = Constants.AUTOMATIC_PUSH_TRACKING,
+        scope = SdkFeatureScope.PUSH_TOKEN_REGISTRATION
+    ),
+
+    // `disable_...` manifest key → reported as the inverse `auto_push_token_forwarding`. Reported
+    // independently of the master flag, so the backend sees how the host set each flag.
+    AUTO_PUSH_TOKEN_FORWARDING(
+        wireName = "auto_push_token_forwarding",
+        manifestKey = Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING,
+        scope = SdkFeatureScope.PUSH_TOKEN_REGISTRATION,
+        reportedValue = { disabled -> !disabled }
+    )
+}
+
+/**
+ * Serializes SDK feature-adoption flags into the `X-Klaviyo-Sdk-Features` header, used for SDK
+ * adoption telemetry.
+ *
+ * Each flag is sourced from a manifest `<meta-data>` boolean and reported only when the host
+ * actually declared that key, so the backend can distinguish "configured false" from "not
+ * configured" (absent keys are omitted from the header).
+ */
+object SdkFeatures {
+    /** Name of the HTTP header these features are serialized into. */
+    const val HEADER_NAME = "X-Klaviyo-Sdk-Features"
+
+    /**
+     * Header value for the given [scope], e.g. `auto_push_tracking=1; auto_push_token_forwarding=0;`.
+     * Includes only in-scope features whose manifest key is present; returns `null` (so callers omit
+     * the header) when none are configured.
+     */
+    fun headerValue(scope: SdkFeatureScope): String? =
+        SdkFeatureKey.entries
+            .filter { it.scope == scope }
+            .mapNotNull { key ->
+                if (Registry.config.hasManifestKey(key.manifestKey)) {
+                    val value = key.reportedValue(
+                        Registry.config.getManifestBoolean(key.manifestKey, false)
+                    )
+                    "${key.wireName}=${if (value) "1" else "0"};"
+                } else {
+                    null
+                }
+            }
+            .takeIf { it.isNotEmpty() }
+            ?.joinToString(" ")
+}
diff --git a/sdk/core/src/main/java/com/klaviyo/core/config/Config.kt b/sdk/core/src/main/java/com/klaviyo/core/config/Config.kt
@@ -30,6 +30,8 @@ interface Config {
 
     fun getManifestBoolean(key: String, defaultValue: Boolean): Boolean
 
+    fun hasManifestKey(key: String): Boolean
+
     interface Builder {
         fun apiKey(apiKey: String): Builder
         fun applicationContext(context: Context): Builder
diff --git a/sdk/core/src/main/java/com/klaviyo/core/config/KlaviyoConfig.kt b/sdk/core/src/main/java/com/klaviyo/core/config/KlaviyoConfig.kt
@@ -153,6 +153,9 @@ object KlaviyoConfig : Config {
             applicationContext.getManifestBoolean(key, defaultValue)
         }
 
+    override fun hasManifestKey(key: String): Boolean =
+        this::applicationContext.isInitialized && applicationContext.hasManifestKey(key)
+
     /**
      * Nested class to enable the builder pattern for easy declaration of custom configurations
      */
@@ -382,3 +385,15 @@ fun Context.getManifestBoolean(key: String, defaultValue: Boolean): Boolean {
     val manifestMetadata = appInfo?.metaData ?: Bundle.EMPTY
     return manifestMetadata.getBoolean(key, defaultValue)
 }
+
+/**
+ * Extension method to check whether a key is present in the manifest metadata at all,
+ * regardless of its value
+ */
+fun Context.hasManifestKey(key: String): Boolean {
+    val pkgName = packageName
+    val pkgManager = packageManager
+    val appInfo = pkgManager.getApplicationInfoCompat(pkgName, PackageManager.GET_META_DATA)
+    val manifestMetadata = appInfo?.metaData ?: Bundle.EMPTY
+    return manifestMetadata.containsKey(key)
+}
diff --git a/sdk/core/src/test/java/com/klaviyo/core/SdkFeaturesTest.kt b/sdk/core/src/test/java/com/klaviyo/core/SdkFeaturesTest.kt
@@ -0,0 +1,95 @@
+package com.klaviyo.core
+
+import com.klaviyo.fixtures.BaseTest
+import io.mockk.every
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+internal class SdkFeaturesTest : BaseTest() {
+
+    /**
+     * Simulate a host declaring [manifestKey] in the manifest with the given boolean [value].
+     * Absent keys are left at BaseTest's defaults (hasManifestKey → false).
+     */
+    private fun stubManifestKey(manifestKey: String, value: Boolean) {
+        every { mockConfig.hasManifestKey(manifestKey) } returns true
+        every { mockConfig.getManifestBoolean(manifestKey, false) } returns value
+    }
+
+    @Test
+    fun `Header omitted when no manifest keys are present`() {
+        assertNull(SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION))
+    }
+
+    @Test
+    fun `Reports only auto_push_tracking when only that key is present and true`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TRACKING.manifestKey, true)
+        assertEquals(
+            "auto_push_tracking=1;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Reports only auto_push_tracking when only that key is present and false`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TRACKING.manifestKey, false)
+        assertEquals(
+            "auto_push_tracking=0;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Reports auto_push_token_forwarding as inverse of the disable flag when disable is true`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TOKEN_FORWARDING.manifestKey, true)
+        assertEquals(
+            "auto_push_token_forwarding=0;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Reports auto_push_token_forwarding as inverse of the disable flag when disable is false`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TOKEN_FORWARDING.manifestKey, false)
+        assertEquals(
+            "auto_push_token_forwarding=1;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Reports both attributes in deterministic order when both keys are present`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TRACKING.manifestKey, true)
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TOKEN_FORWARDING.manifestKey, true)
+        assertEquals(
+            "auto_push_tracking=1; auto_push_token_forwarding=0;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Omits an absent key even when the other in-scope key is present`() {
+        stubManifestKey(SdkFeatureKey.AUTO_PUSH_TRACKING.manifestKey, false)
+        // Forwarding-disable key left absent
+        assertEquals(
+            "auto_push_tracking=0;",
+            SdkFeatures.headerValue(SdkFeatureScope.PUSH_TOKEN_REGISTRATION)
+        )
+    }
+
+    @Test
+    fun `Every feature key resolves exactly one scope`() {
+        // Guard: a future entry cannot be added without a (non-null) scope, so it can't silently
+        // escape the scope filter.
+        SdkFeatureKey.entries.forEach { key ->
+            assertNotNull(key.scope)
+        }
+    }
+
+    @Test
+    fun `Header name matches the agreed wire contract`() {
+        assertEquals("X-Klaviyo-Sdk-Features", SdkFeatures.HEADER_NAME)
+    }
+}
diff --git a/sdk/core/src/test/java/com/klaviyo/core/config/KlaviyoConfigTest.kt b/sdk/core/src/test/java/com/klaviyo/core/config/KlaviyoConfigTest.kt
@@ -268,4 +268,35 @@ internal class KlaviyoConfigTest : BaseTest() {
         assertEquals(true, mockContext.getManifestBoolean("missing.key", true))
         assertEquals(false, mockContext.getManifestBoolean("missing.key", false))
     }
+
+    @Test
+    fun `hasManifestKey reflects presence of the key, regardless of its value`() {
+        // Back the Bundle with a real map so containsKey has genuine present/absent semantics
+        // rather than echoing a stubbed return.
+        val metadata = mutableMapOf(
+            "com.klaviyo.present_true" to true,
+            "com.klaviyo.present_false" to false
+        )
+        val mockMetadata = mockk<Bundle> {
+            every { containsKey(any()) } answers { metadata.containsKey(firstArg()) }
+        }
+        mockApplicationInfo.metaData = mockMetadata
+
+        mockkStatic(PackageManager.ApplicationInfoFlags::class)
+        val mockApplicationInfoFlags = mockk<PackageManager.ApplicationInfoFlags>()
+        every { PackageManager.ApplicationInfoFlags.of(any()) } returns mockApplicationInfoFlags
+        setFinalStatic(Build.VERSION::class.java.getField("SDK_INT"), 33)
+        every {
+            mockPackageManager.getApplicationInfo(
+                BuildConfig.LIBRARY_PACKAGE_NAME,
+                mockApplicationInfoFlags
+            )
+        } returns mockApplicationInfo
+
+        // Present regardless of whether the value is true or false.
+        assertEquals(true, mockContext.hasManifestKey("com.klaviyo.present_true"))
+        assertEquals(true, mockContext.hasManifestKey("com.klaviyo.present_false"))
+        // Absent key is reported as absent.
+        assertEquals(false, mockContext.hasManifestKey("missing.key"))
+    }
 }
diff --git a/sdk/fixtures/src/main/java/com/klaviyo/fixtures/BaseTest.kt b/sdk/fixtures/src/main/java/com/klaviyo/fixtures/BaseTest.kt
@@ -99,6 +99,8 @@ abstract class BaseTest {
         every { formEnvironment } returns FormEnvironment.IN_APP
         // Default to the passed default (e.g. automatic push tracking off); override per-test to flip on
         every { getManifestBoolean(any(), any()) } answers { secondArg() }
+        // Default to no manifest keys present; override per-test to simulate a host declaring one
+        every { hasManifestKey(any()) } returns false
     }
 
     protected val mockActivity: Activity = mockk(relaxed = true)

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,8 @@ abstract class BaseTest {`
`99`	`99`	`every { formEnvironment } returns FormEnvironment.IN_APP`
`100`	`100`	`// Default to the passed default (e.g. automatic push tracking off); override per-test to flip on`
`101`	`101`	`every { getManifestBoolean(any(), any()) } answers { secondArg() }`
	`102`	`+ // Default to no manifest keys present; override per-test to simulate a host declaring one`
	`103`	`+ every { hasManifestKey(any()) } returns false`
`102`	`104`	`}`
`103`	`105`
`104`	`106`	`protected val mockActivity: Activity = mockk(relaxed = true)`