Merge pull request #243 from reown-com/feat/pos_observability

feat: add events observability to POS

Author: jakubuid

.github/workflows/ci_assemble.yml

@@ -46,6 +46,7 @@ jobs:
       - name: Assemble Debug Project
         env:
           WC_CLOUD_PROJECT_ID: ${{ secrets.WC_CLOUD_PROJECT_ID }}
+          POS_PROJECT_ID: ${{ secrets.POS_PROJECT_ID }}
           NOTIFY_INTEGRATION_TESTS_PROJECT_ID: ${{ secrets.NOTIFY_INTEGRATION_TESTS_PROJECT_ID }}
           NOTIFY_INTEGRATION_TESTS_SECRET: ${{ secrets.NOTIFY_INTEGRATION_TESTS_SECRET }}
         # See if we can build out the list of sample project instead of manually adding them here

.github/workflows/ci_debug_sample.yml

@@ -10,7 +10,8 @@ jobs:
         conf: [
           { name: wallet, command: ":sample:wallet:assembleDebug :sample:wallet:appDistributionUploadDebug" },
           { name: dapp, command: ":sample:dapp:assembleDebug :sample:dapp:appDistributionUploadDebug" },
-          { name: modal, command: ":sample:modal:assembleDebug :sample:modal:appDistributionUploadDebug" }
+          { name: modal, command: ":sample:modal:assembleDebug :sample:modal:appDistributionUploadDebug" },
+          { name: pos, command: ":sample:pos:assembleDebug" }
         ]
     name: ${{ matrix.conf.name }}
     runs-on: ubuntu-latest
@@ -51,6 +52,7 @@ jobs:
       - name: Release sample - Debug
         env:
           WC_CLOUD_PROJECT_ID: ${{ secrets.WC_CLOUD_PROJECT_ID }}
+          POS_PROJECT_ID: ${{ secrets.POS_PROJECT_ID }}
           FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
           NOTIFY_INTEGRATION_TESTS_PROJECT_ID: ${{ secrets.NOTIFY_INTEGRATION_TESTS_PROJECT_ID }}
           NOTIFY_INTEGRATION_TESTS_SECRET: ${{ secrets.NOTIFY_INTEGRATION_TESTS_SECRET }}

.github/workflows/ci_internal_sample.yml

@@ -19,7 +19,8 @@ jobs:
         conf: [
           { name: wallet, command: ":sample:wallet:assembleInternal :sample:wallet:appDistributionUploadInternal" },
           { name: dapp, command: ":sample:dapp:assembleInternal :sample:dapp:appDistributionUploadInternal" },
-          { name: modal, command: ":sample:modal:assembleInternal :sample:modal:appDistributionUploadInternal" }
+          { name: modal, command: ":sample:modal:assembleInternal :sample:modal:appDistributionUploadInternal" },
+          { name: pos, command: ":sample:pos:assembleInternal" }
         ]
     name: ${{ matrix.conf.name }}
     runs-on: ubuntu-latest
@@ -60,6 +61,7 @@ jobs:
       - name: Release sample - Internal
         env:
           WC_CLOUD_PROJECT_ID: ${{ secrets.WC_CLOUD_PROJECT_ID }}
+          POS_PROJECT_ID: ${{ secrets.POS_PROJECT_ID }}
           FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
           NOTIFY_INTEGRATION_TESTS_PROJECT_ID: ${{ secrets.NOTIFY_INTEGRATION_TESTS_PROJECT_ID }}
           NOTIFY_INTEGRATION_TESTS_SECRET: ${{ secrets.NOTIFY_INTEGRATION_TESTS_SECRET }}

product/pos/build.gradle.kts

@@ -26,11 +26,17 @@ android {
 
         buildConfigField(type = "String", name = "SDK_VERSION", value = "\"${requireNotNull(extra.get(KEY_PUBLISH_VERSION))}\"")
         buildConfigField(type = "String", name = "CORE_API_BASE_URL", value = "\"https://api.pay.walletconnect.com\"")
+        buildConfigField(type = "String", name = "PULSE_BASE_URL", value = "\"https://pulse.walletconnect.org\"")
+        buildConfigField(type = "String", name = "POS_PROJECT_ID", value = "\"${System.getenv("POS_PROJECT_ID") ?: ""}\"")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
     buildTypes {
+        debug {
+            buildConfigField(type = "String", name = "INGEST_BASE_URL", value = "\"https://ingest-staging.walletconnect.org/\"")
+        }
         release {
+            buildConfigField(type = "String", name = "INGEST_BASE_URL", value = "\"https://ingest.walletconnect.org/\"")
             isMinifyEnabled = false
             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
         }

product/pos/src/main/kotlin/com/walletconnect/pos/PosClient.kt

@@ -2,6 +2,8 @@ package com.walletconnect.pos
 
 import com.walletconnect.pos.api.ApiClient
 import com.walletconnect.pos.api.ApiResult
+import com.walletconnect.pos.api.ErrorTracker
+import com.walletconnect.pos.api.EventTracker
 import com.walletconnect.pos.api.mapErrorCodeToPaymentError
 import com.walletconnect.pos.api.mapStatusToPaymentEvent
 import kotlinx.coroutines.CoroutineScope
@@ -17,6 +19,8 @@ import kotlinx.coroutines.launch
 object PosClient {
     private var delegate: POSDelegate? = null
     private var apiClient: ApiClient? = null
+    private var eventTracker: EventTracker? = null
+    private var errorTracker: ErrorTracker? = null
     private var scope: CoroutineScope? = null
     private var currentPollingJob: Job? = null
 
@@ -33,8 +37,11 @@ object PosClient {
         check(merchantId.isNotBlank()) { "merchantId cannot be blank" }
         check(deviceId.isNotBlank()) { "deviceId cannot be blank" }
         cleanup()
-        this.scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
-        this.apiClient = ApiClient(apiKey, merchantId)
+        val newScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+        this.scope = newScope
+        this.eventTracker = EventTracker(merchantId, newScope)
+        this.errorTracker = ErrorTracker(newScope)
+        this.apiClient = ApiClient(apiKey, merchantId, eventTracker!!, errorTracker!!)
     }
 
     /**
@@ -58,6 +65,8 @@ object PosClient {
     fun createPaymentIntent(amount: Pos.Amount, referenceId: String) {
         checkInitialized()
         currentPollingJob?.cancel()
+        val valueMinor = amount.value.toLongOrNull() ?: 0L
+        eventTracker?.trackWcPaySelected(referenceId, amount.unit, valueMinor)
         currentPollingJob = scope?.launch {
             apiClient!!.createPayment(referenceId, amount.unit, amount.value) { event ->
                 emitEvent(event)
@@ -118,5 +127,7 @@ object PosClient {
         scope?.cancel()
         scope = null
         apiClient = null
+        eventTracker = null
+        errorTracker = null
     }
 }

product/pos/src/main/kotlin/com/walletconnect/pos/api/ApiClient.kt

@@ -19,6 +19,8 @@ import java.util.concurrent.TimeUnit
 internal class ApiClient(
     private val apiKey: String,
     private val merchantId: String,
+    private val eventTracker: EventTracker,
+    private val errorTracker: ErrorTracker,
     baseUrl: String = BuildConfig.CORE_API_BASE_URL
 ) {
     private val moshi = Moshi.Builder()
@@ -70,31 +72,45 @@ internal class ApiClient(
                     return
                 }
 
-                onEvent(
-                    Pos.PaymentEvent.PaymentCreated(
-                        uri = URI(data.gatewayUrl),
-                        amount = Pos.Amount(unit, value),
-                        paymentId = data.paymentId
-                    )
+                val paymentCreatedEvent = Pos.PaymentEvent.PaymentCreated(
+                    uri = URI(data.gatewayUrl),
+                    amount = Pos.Amount(unit, value),
+                    paymentId = data.paymentId
                 )
+                val valueMinor = value.toLongOrNull() ?: 0L
+                val context = PaymentContext(
+                    paymentUrl = data.gatewayUrl,
+                    unit = unit,
+                    valueMinor = valueMinor,
+                    referenceId = referenceId.ifBlank { null }
+                )
+                eventTracker.trackPaymentCreated(data.paymentId, context)
+                onEvent(paymentCreatedEvent)
 
-                startPolling(data.paymentId, onEvent)
+                startPolling(data.paymentId, context, onEvent)
             } else {
                 val error = parseErrorResponse(response)
-                onEvent(mapCreatePaymentError(error.code, error.message))
+                val paymentError = mapCreatePaymentError(error.code, error.message)
+                eventTracker.trackPaymentFailed(referenceId, null, paymentError)
+                onEvent(paymentError)
             }
         } catch (e: CancellationException) {
             // Rethrow cancellation to properly propagate coroutine cancellation
             throw e
         } catch (e: IOException) {
-            onEvent(Pos.PaymentEvent.PaymentError.CreatePaymentFailed("Network error: ${e.message}"))
+            errorTracker.trackError(PulseErrorType.NETWORK_ERROR, e.message ?: "Network error", "createPayment")
+            val paymentError = Pos.PaymentEvent.PaymentError.CreatePaymentFailed("Network error: ${e.message}")
+            onEvent(paymentError)
         } catch (e: Exception) {
-            onEvent(Pos.PaymentEvent.PaymentError.Undefined("Unexpected error: ${e.message}"))
+            errorTracker.trackError(PulseErrorType.SDK_ERROR, e.message ?: "Unexpected error", "createPayment")
+            val paymentError = Pos.PaymentEvent.PaymentError.Undefined("Unexpected error: ${e.message}")
+            onEvent(paymentError)
         }
     }
 
     private suspend fun startPolling(
         paymentId: String,
+        context: PaymentContext,
         onEvent: (Pos.PaymentEvent) -> Unit
     ) {
         var lastEmittedStatus: String? = null
@@ -106,7 +122,9 @@ internal class ApiClient(
 
                     if (data.status != lastEmittedStatus) {
                         lastEmittedStatus = data.status
-                        onEvent(mapStatusToPaymentEvent(data.status, paymentId))
+                        val event = mapStatusToPaymentEvent(data.status, paymentId)
+                        trackPaymentStatusEvent(paymentId, context, data.status, event)
+                        onEvent(event)
                     }
 
                     if (data.isFinal || data.pollInMs == null) {
@@ -117,13 +135,35 @@ internal class ApiClient(
                 }
 
                 is ApiResult.Error -> {
-                    onEvent(mapErrorCodeToPaymentError(result.code, result.message))
+                    val paymentError = mapErrorCodeToPaymentError(result.code, result.message)
+                    if (!isSdkError(result.code)) {
+                        eventTracker.trackPaymentFailed(paymentId, context, paymentError)
+                    }
+                    onEvent(paymentError)
                     break
                 }
             }
         }
     }
 
+    private fun trackPaymentStatusEvent(
+        paymentId: String,
+        context: PaymentContext,
+        status: String,
+        event: Pos.PaymentEvent
+    ) {
+        when (status) {
+            PaymentStatus.REQUIRES_ACTION -> eventTracker.trackPaymentRequested(paymentId, context)
+            PaymentStatus.PROCESSING -> eventTracker.trackPaymentProcessing(paymentId, context)
+            PaymentStatus.SUCCEEDED -> eventTracker.trackPaymentCompleted(paymentId, context)
+            PaymentStatus.EXPIRED, PaymentStatus.FAILED -> {
+                if (event is Pos.PaymentEvent.PaymentError) {
+                    eventTracker.trackPaymentFailed(paymentId, context, event)
+                }
+            }
+        }
+    }
+
     suspend fun getPaymentStatus(paymentId: String): ApiResult<GetPaymentStatusResponse> {
         return try {
             val response = payApi.getPaymentStatus(paymentId)
@@ -143,8 +183,10 @@ internal class ApiClient(
             // Rethrow cancellation to properly propagate coroutine cancellation
             throw e
         } catch (e: IOException) {
+            errorTracker.trackError(PulseErrorType.NETWORK_ERROR, e.message ?: "Network error", "getPaymentStatus")
             ApiResult.Error(ErrorCodes.NETWORK_ERROR, e.message ?: "Network error")
         } catch (e: Exception) {
+            errorTracker.trackError(PulseErrorType.SDK_ERROR, e.message ?: "Unexpected error", "getPaymentStatus")
             ApiResult.Error(ErrorCodes.PARSE_ERROR, e.message ?: "Unexpected error")
         }
     }
@@ -172,6 +214,7 @@ internal class ApiClient(
                     message = response.message()
                 )
             } catch (e: Exception) {
+                errorTracker.trackError(PulseErrorType.PARSE_ERROR, e.message ?: "Failed to parse error response", "parseErrorResponse")
                 ApiErrorDetails(
                     code = "HTTP_${response.code()}",
                     message = response.message()
@@ -185,6 +228,10 @@ internal class ApiClient(
         }
     }
 
+    private fun isSdkError(code: String): Boolean {
+        return code == ErrorCodes.NETWORK_ERROR || code == ErrorCodes.PARSE_ERROR
+    }
+
     private fun String.ensureTrailingSlash(): String {
         return if (endsWith("/")) this else "$this/"
     }

product/pos/src/main/kotlin/com/walletconnect/pos/api/ErrorTracker.kt

@@ -0,0 +1,103 @@
+package com.walletconnect.pos.api
+
+import com.squareup.moshi.Moshi
+import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
+import com.walletconnect.pos.BuildConfig
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import retrofit2.Retrofit
+import retrofit2.converter.moshi.MoshiConverterFactory
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+
+internal class ErrorTracker(
+    private val scope: CoroutineScope,
+    baseUrl: String = BuildConfig.PULSE_BASE_URL
+) {
+    private val moshi = Moshi.Builder()
+        .addLast(KotlinJsonAdapterFactory())
+        .build()
+
+    private val httpClient = OkHttpClient.Builder()
+        .connectTimeout(15, TimeUnit.SECONDS)
+        .readTimeout(15, TimeUnit.SECONDS)
+        .writeTimeout(15, TimeUnit.SECONDS)
+        .apply {
+            if (BuildConfig.DEBUG) {
+                addInterceptor(HttpLoggingInterceptor().apply {
+                    level = HttpLoggingInterceptor.Level.BODY
+                })
+            }
+        }
+        .build()
+
+    private val retrofit = Retrofit.Builder()
+        .baseUrl(baseUrl.ensureTrailingSlash())
+        .client(httpClient)
+        .addConverterFactory(MoshiConverterFactory.create(moshi))
+        .build()
+
+    private val pulseApi: PulseApi = retrofit.create(PulseApi::class.java)
+
+    private val silentExceptionHandler = CoroutineExceptionHandler { _, t -> println(t) }
+
+    companion object {
+        private const val MAX_RETRIES = 3
+        private val RETRY_DELAYS_MS = listOf(1000L, 3000L, 5000L)
+        private const val SDK_TYPE = "pos"
+    }
+
+    fun trackError(type: String, message: String, method: String) {
+        try {
+            val event = PulseEvent(
+                eventId = UUID.randomUUID().toString(),
+                timestamp = System.currentTimeMillis(),
+                props = PulseProps(
+                    type = type,
+                    properties = PulseErrorProperties(
+                        message = message,
+                        method = method
+                    )
+                )
+            )
+
+            scope.launch(Dispatchers.IO + silentExceptionHandler) {
+                sendWithRetry(event)
+            }
+        } catch (_: Exception) {
+            // Silently ignore any synchronous errors
+            // Error tracking should never affect the main flow
+        }
+    }
+
+    private suspend fun sendWithRetry(event: PulseEvent) {
+        repeat(MAX_RETRIES) { attempt ->
+            try {
+                val response = pulseApi.sendEvent(
+                    sdkType = SDK_TYPE,
+                    sdkVersion = BuildConfig.SDK_VERSION,
+                    projectId = BuildConfig.POS_PROJECT_ID,
+                    body = event
+                )
+                if (response.isSuccessful) {
+                    return
+                }
+            } catch (_: Exception) {
+                // Network or other error, retry silently
+            }
+
+            if (attempt < MAX_RETRIES - 1) {
+                delay(RETRY_DELAYS_MS[attempt])
+            }
+        }
+    }
+
+    private fun String.ensureTrailingSlash(): String {
+        return if (endsWith("/")) this else "$this/"
+    }
+}