fix

Author: jose-sequeira

posthog/src/main/java/com/posthog/internal/GzipRequestInterceptor.kt

@@ -36,7 +36,7 @@ import java.io.IOException
  * This interceptor compresses the HTTP request body. Many webservers can't handle this!
  * @property config The Config
  */
-internal class GzipRequestInterceptor(private val config: PostHogConfig) : Interceptor {
+public class GzipRequestInterceptor(private val config: PostHogConfig) : Interceptor {
     @Throws(IOException::class)
     override fun intercept(chain: Interceptor.Chain): Response {
         val originalRequest = chain.request()

sdk_compliance_adapter/Dockerfile

@@ -4,17 +4,18 @@ WORKDIR /app
 
 COPY . .
 
-RUN gradle :sdk_compliance_adapter:build --no-daemon
+RUN echo 'include(":sdk_compliance_adapter")' >> settings.gradle.kts && \
+    sed -i '/^dependencyResolutionManagement/i plugins {\n    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"\n}' settings.gradle.kts && \
+    mkdir -p /root/.gradle && \
+    echo 'org.gradle.java.installations.auto-download=true' > /root/.gradle/gradle.properties && \
+    gradle :sdk_compliance_adapter:installDist --no-daemon
 
 FROM eclipse-temurin:11-jre
 
 WORKDIR /app
 
-# Copy the built JAR
-COPY --from=builder /app/sdk_compliance_adapter/build/libs/*.jar /app/adapter.jar
+COPY --from=builder /app/sdk_compliance_adapter/build/install/sdk_compliance_adapter /app
 
-# Expose port
 EXPOSE 8080
 
-# Run the adapter
-CMD ["java", "-jar", "/app/adapter.jar"]
+CMD ["/app/bin/sdk_compliance_adapter"]

sdk_compliance_adapter/README.md

@@ -0,0 +1,97 @@
+# PostHog Android SDK Compliance Adapter
+
+This compliance adapter wraps the PostHog Android SDK and exposes a standardized HTTP API for automated compliance testing using the [PostHog SDK Test Harness](https://github.com/PostHog/posthog-sdk-test-harness).
+
+## Quick Start
+
+### Running Tests in CI (Recommended)
+
+Tests run automatically in GitHub Actions on:
+- Push to `main`/`master` branch
+- Pull requests
+- Manual trigger via `workflow_dispatch`
+
+See `.github/workflows/sdk-compliance-tests.yml`
+
+### Running Tests Locally
+
+**Note:** Requires x86_64 architecture due to Java 8 dependency. On Apple Silicon, Docker will use emulation (slower but works).
+
+```bash
+cd sdk_compliance_adapter
+docker-compose up --build --abort-on-container-exit
+```
+
+## Architecture
+
+- **adapter.kt** - Ktor HTTP server implementing the compliance adapter API
+- **TrackingInterceptor** - OkHttp interceptor for monitoring SDK HTTP requests
+- **Dockerfile** - Multi-stage Docker build (requires x86_64 for Java 8)
+- **docker-compose.yml** - Local test orchestration
+
+## SDK Modifications
+
+To enable request tracking, we added an optional `httpClient` parameter to `PostHogConfig`:
+
+```kotlin
+// PostHogConfig.kt
+public var httpClient: okhttp3.OkHttpClient? = null
+```
+
+This allows the test adapter to inject a custom OkHttpClient with tracking interceptors. **This change is fully backward compatible** - existing code works unchanged.
+
+## Implementation Details
+
+### HTTP Request Tracking
+
+The adapter injects a custom OkHttpClient that:
+- Intercepts all `/batch/` requests
+- Extracts event UUIDs from request bodies
+- Tracks status codes, retry attempts, and event counts
+
+### Event Tracking
+
+Events are tracked via:
+1. `beforeSend` hook - Captures UUIDs as events are queued
+2. HTTP interceptor - Verifies UUIDs in outgoing requests
+
+### SDK Type
+
+The Android SDK uses **server SDK format**:
+- Endpoint: `/batch/`
+- Format: `{api_key, batch, sent_at}`
+
+Tests run with `--sdk-type server`.
+
+## Files Created
+
+```
+sdk_compliance_adapter/
+├── adapter.kt              # Main adapter implementation
+├── build.gradle.kts        # Gradle build configuration
+├── Dockerfile              # Docker build (x86_64)
+├── docker-compose.yml      # Local test setup
+├── README.md               # This file
+└── IMPLEMENTATION_NOTES.md # Detailed technical notes
+```
+
+## Changes to Core SDK
+
+### posthog/src/main/java/com/posthog/PostHogConfig.kt
+- Added `httpClient: OkHttpClient?` parameter
+
+### posthog/src/main/java/com/posthog/internal/PostHogApi.kt
+- Modified to use injected `httpClient` if provided
+
+### settings.gradle.kts
+- Added `:sdk_compliance_adapter` module
+
+### .github/workflows/sdk-compliance-tests.yml
+- GitHub Actions workflow for automated testing
+
+## References
+
+- [Test Harness Repository](https://github.com/PostHog/posthog-sdk-test-harness)
+- [Adapter Guide](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/ADAPTER_GUIDE.md)
+- [Contract Specification](https://github.com/PostHog/posthog-sdk-test-harness/blob/main/CONTRACT.yaml)
+- [Browser SDK Adapter](https://github.com/PostHog/posthog-js/tree/main/packages/browser/sdk_compliance_adapter) (Reference)

sdk_compliance_adapter/build.gradle.kts

@@ -1,18 +1,14 @@
 plugins {
-    kotlin("jvm") version "1.9.22"
+    kotlin("jvm")
     application
 }
 
 group = "com.posthog.compliance"
 version = "1.0.0"
 
-repositories {
-    mavenCentral()
-}
-
 dependencies {
-    // PostHog Server SDK (simpler for testing)
-    implementation(project(":posthog-server"))
+    // PostHog Core SDK
+    implementation(project(":posthog"))
 
     // Ktor server
     val ktorVersion = "2.3.7"
@@ -42,3 +38,8 @@ java {
     sourceCompatibility = JavaVersion.VERSION_11
     targetCompatibility = JavaVersion.VERSION_11
 }
+
+// Disable API validation for test adapter
+tasks.matching { it.name == "apiCheck" || it.name == "apiDump" }.configureEach {
+    enabled = false
+}

sdk_compliance_adapter/docker-compose.yml

@@ -1,19 +1,5 @@
-version: '3.8'
-
 services:
-  test-harness:
-    image: posthog-sdk-test-harness:latest
-    command: ["--sdk-type", "server"]
-    depends_on:
-      - adapter
-      - mock-server
-    environment:
-      - ADAPTER_URL=http://adapter:8080
-      - MOCK_SERVER_URL=http://mock-server:8081
-    networks:
-      - test-network
-
-  adapter:
+  sdk-adapter:
     build:
       context: ..
       dockerfile: sdk_compliance_adapter/Dockerfile
@@ -24,13 +10,13 @@ services:
     environment:
       - JAVA_TOOL_OPTIONS=-Xmx512m
 
-  mock-server:
-    image: posthog-sdk-test-harness:latest
-    command: ["mock-server"]
-    ports:
-      - "8081:8081"
+  test-harness:
+    image: posthog-sdk-test-harness:debug
+    command: ["run", "--adapter-url", "http://sdk-adapter:8080", "--mock-url", "http://test-harness:8081", "--sdk-type", "server", "--debug"]
     networks:
       - test-network
+    depends_on:
+      - sdk-adapter
 
 networks:
   test-network:

sdk_compliance_adapter/adapter.kt …kotlin/com/posthog/compliance/adapter.ktsdk_compliance_adapter/adapter.kt renamed to sdk_compliance_adapter/src/main/kotlin/com/posthog/compliance/adapter.kt sdk_compliance_adapter/adapter.kt renamed to sdk_compliance_adapter/src/main/kotlin/com/posthog/compliance/adapter.kt

@@ -2,6 +2,7 @@ package com.posthog.compliance
 
 import com.posthog.PostHog
 import com.posthog.PostHogConfig
+import com.posthog.internal.GzipRequestInterceptor
 import io.ktor.http.*
 import io.ktor.serialization.gson.*
 import io.ktor.server.application.*
@@ -13,6 +14,7 @@ import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import okhttp3.Interceptor
 import okhttp3.Response
+import com.posthog.internal.PostHogContext
 import java.util.*
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -87,11 +89,21 @@ data class SuccessResponse(
     val success: Boolean
 )
 
+// Minimal context for testing (provides $lib and $lib_version)
+class TestPostHogContext(private val sdkName: String, private val sdkVersion: String) : PostHogContext {
+    override fun getStaticContext(): Map<String, Any> = emptyMap()
+    override fun getDynamicContext(): Map<String, Any> = emptyMap()
+    override fun getSdkInfo(): Map<String, Any> = mapOf(
+        "\$lib" to sdkName,
+        "\$lib_version" to sdkVersion
+    )
+}
+
 // Global state
 object AdapterContext {
     val state = AdapterState()
     val lock = ReentrantLock()
-    var postHog: PostHog? = null
+    var postHog: com.posthog.PostHogInterface? = null
     val capturedEvents = mutableListOf<String>() // Store UUIDs of captured events
 }
 
@@ -214,21 +226,36 @@ fun main() {
                     // Close existing instance if any
                     AdapterContext.postHog?.close()
 
-                    // Create OkHttpClient with tracking interceptor
+                    // Create config first (needed for GzipRequestInterceptor)
+                    val tempConfig = PostHogConfig(apiKey = req.api_key, host = req.host)
+
+                    // Create OkHttpClient with tracking interceptor first, then gzip
+                    // Order matters: TrackingInterceptor reads uncompressed body, GzipInterceptor compresses it
                     val httpClient = okhttp3.OkHttpClient.Builder()
                         .addInterceptor(TrackingInterceptor())
+                        .addInterceptor(GzipRequestInterceptor(tempConfig))
                         .build()
 
                     // Create new config
+                    val flushIntervalMs = req.flush_interval_ms ?: 100
+                    val flushIntervalSeconds = maxOf(1, flushIntervalMs / 1000) // Min 1 second
+
                     val config = PostHogConfig(
                         apiKey = req.api_key,
                         host = req.host,
-                        flushAt = req.flush_at ?: 1, // Flush immediately for tests
-                        flushIntervalSeconds = (req.flush_interval_ms ?: 100) / 1000,
+                        flushAt = req.flush_at ?: 1,
+                        flushIntervalSeconds = flushIntervalSeconds,
                         debug = true,
-                        httpClient = httpClient
+                        httpClient = httpClient,
+                        preloadFeatureFlags = false // Disable to avoid 404 on /flags/
                     )
 
+                    // Set storage prefix for file-backed queue
+                    config.storagePrefix = "/tmp/posthog-queue"
+
+                    // Set minimal context to provide $lib and $lib_version
+                    config.context = TestPostHogContext("posthog-android", "3.28.0")
+
                     // Add beforeSend hook to track captured events
                     config.addBeforeSend { event ->
                         AdapterContext.lock.withLock {
@@ -254,21 +281,24 @@ fun main() {
                 println("[ADAPTER] Capturing event: ${req.event} for user: ${req.distinct_id}")
 
                 val ph = AdapterContext.lock.withLock {
-                    AdapterContext.postHog ?: run {
-                        call.respond(HttpStatusCode.BadRequest, mapOf("error" to "SDK not initialized"))
-                        return@post
-                    }
+                    AdapterContext.postHog
                 }
 
-                // Set distinct_id
-                ph.identify(req.distinct_id)
+                if (ph == null) {
+                    call.respond(HttpStatusCode.BadRequest, mapOf("error" to "SDK not initialized"))
+                    return@post
+                }
 
                 // Remember the count before capturing
                 val beforeCount = AdapterContext.capturedEvents.size
 
-                // Capture event
+                // Capture event with distinct_id parameter (don't call identify separately)
                 val properties = req.properties?.toMutableMap() ?: mutableMapOf()
-                ph.capture(req.event, properties)
+                ph.capture(
+                    event = req.event,
+                    distinctId = req.distinct_id,
+                    properties = properties
+                )
 
                 // Get the UUID that was just captured (via beforeSend hook)
                 val uuid = AdapterContext.lock.withLock {

settings.gradle.kts

@@ -18,7 +18,6 @@ rootProject.name = "PostHog"
 include(":posthog")
 include(":posthog-android")
 include(":posthog-server")
-include(":sdk_compliance_adapter")
 
 // samples
 include(":posthog-samples:posthog-android-sample")