UTD posthog reporting add more properties to captured event

changelog.d/8780.misc

@@ -0,0 +1 @@
+Improve UTD reporting by adding additional fields to the report.

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/LiveEventListener.kt

@@ -16,6 +16,7 @@
 
 package org.matrix.android.sdk.api.session
 
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
 import org.matrix.android.sdk.api.session.events.model.Event
 import org.matrix.android.sdk.api.util.JsonDict
 
@@ -27,7 +28,7 @@ interface LiveEventListener {
 
     fun onEventDecrypted(event: Event, clearEvent: JsonDict)
 
-    fun onEventDecryptionError(event: Event, throwable: Throwable)
+    fun onEventDecryptionError(event: Event, cryptoError: MXCryptoError)
 
     fun onLiveToDeviceEvent(event: Event)
 

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/Device.kt

@@ -172,8 +172,6 @@ internal class Device @AssistedInject constructor(
      * This will not fetch out fresh data from the Rust side.
      **/
     internal fun toCryptoDeviceInfo(): CryptoDeviceInfo {
-//        val keys = innerDevice.keys.map { (keyId, key) -> keyId to key }.toMap()
-
         return CryptoDeviceInfo(
                 deviceId = innerDevice.deviceId,
                 userId = innerDevice.userId,

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OlmMachine.kt

@@ -189,18 +189,21 @@ internal class OlmMachine @Inject constructor(
             is OwnUserIdentity -> ownIdentity.trustsOurOwnDevice()
             else -> false
         }
+        val ownDevice = inner.getDevice(userId(), deviceId, 0u)!!
+        val creationTime = ownDevice.firstTimeSeenTs.toLong()
 
         return CryptoDeviceInfo(
                 deviceId(),
                 userId(),
-                // TODO pass the algorithms here.
-                listOf(),
+                ownDevice.algorithms,
                 keys,
                 mapOf(),
-                UnsignedDeviceInfo(),
+                UnsignedDeviceInfo(
+                        deviceDisplayName = ownDevice.displayName
+                ),
                 DeviceTrustLevel(crossSigningVerified, locallyVerified = true),
                 false,
-                null
+                creationTime
         )
     }
 
@@ -291,7 +294,7 @@ internal class OlmMachine @Inject constructor(
             // checking the returned to devices to check for room keys.
             // XXX Anyhow there is now proper signaling we should soon stop parsing them manually
             receiveSyncChanges.toDeviceEvents.map {
-                        outAdapter.fromJson(it) ?: Event()
+                outAdapter.fromJson(it) ?: Event()
             }
         }
 
@@ -882,6 +885,7 @@ internal class OlmMachine @Inject constructor(
             inner.queryMissingSecretsFromOtherSessions()
         }
     }
+
     @Throws(CryptoStoreException::class)
     suspend fun enableBackupV1(key: String, version: String) {
         return withContext(coroutineDispatchers.computation) {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/StreamEventsManager.kt

@@ -22,6 +22,7 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import org.matrix.android.sdk.api.extensions.tryOrNull
 import org.matrix.android.sdk.api.session.LiveEventListener
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
 import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
 import org.matrix.android.sdk.api.session.events.model.Event
 import timber.log.Timber
@@ -75,7 +76,7 @@ internal class StreamEventsManager @Inject constructor() {
         }
     }
 
-    fun dispatchLiveEventDecryptionFailed(event: Event, error: Throwable) {
+    fun dispatchLiveEventDecryptionFailed(event: Event, error: MXCryptoError) {
         Timber.v("## dispatchLiveEventDecryptionFailed ${event.eventId}")
         coroutineScope.launch {
             listeners.forEach {

vector-app/src/main/java/im/vector/app/VectorApplication.kt

@@ -51,6 +51,7 @@ import im.vector.app.core.debug.LeakDetector
 import im.vector.app.core.di.ActiveSessionHolder
 import im.vector.app.core.pushers.FcmHelper
 import im.vector.app.core.resources.BuildMeta
+import im.vector.app.features.analytics.DecryptionFailureTracker
 import im.vector.app.features.analytics.VectorAnalytics
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.configuration.VectorConfiguration
@@ -100,6 +101,7 @@ class VectorApplication :
     @Inject lateinit var callManager: WebRtcCallManager
     @Inject lateinit var invitesAcceptor: InvitesAcceptor
     @Inject lateinit var autoRageShaker: AutoRageShaker
+    @Inject lateinit var decryptionFailureTracker: DecryptionFailureTracker
     @Inject lateinit var vectorFileLogger: VectorFileLogger
     @Inject lateinit var vectorAnalytics: VectorAnalytics
     @Inject lateinit var flipperProxy: FlipperProxy
@@ -130,6 +132,7 @@ class VectorApplication :
         vectorAnalytics.init()
         invitesAcceptor.initialize()
         autoRageShaker.initialize()
+        decryptionFailureTracker.start()
         vectorUncaughtExceptionHandler.activate()
 
         // Remove Log handler statically added by Jitsi

vector/src/main/java/im/vector/app/UISIDetector.kt

@@ -18,6 +18,7 @@ package im.vector.app
 
 import org.matrix.android.sdk.api.extensions.orFalse
 import org.matrix.android.sdk.api.session.LiveEventListener
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
 import org.matrix.android.sdk.api.session.events.model.Event
 import org.matrix.android.sdk.api.session.events.model.content.EncryptedEventContent
 import org.matrix.android.sdk.api.session.events.model.toModel
@@ -84,7 +85,7 @@ class UISIDetector(private val timeoutMillis: Long = 30_000L) : LiveEventListene
         }
     }
 
-    override fun onEventDecryptionError(event: Event, throwable: Throwable) {
+    override fun onEventDecryptionError(event: Event, cryptoError: MXCryptoError) {
         val eventId = event.eventId
         val roomId = event.roomId
         if (!enabled || eventId == null || roomId == null) return

vector/src/main/java/im/vector/app/core/di/ActiveSessionHolder.kt

@@ -23,7 +23,6 @@ import im.vector.app.core.pushers.UnregisterUnifiedPushUseCase
 import im.vector.app.core.services.GuardServiceStarter
 import im.vector.app.core.session.ConfigureAndStartSessionUseCase
 import im.vector.app.features.analytics.DecryptionFailureTracker
-import im.vector.app.features.analytics.plan.Error
 import im.vector.app.features.call.webrtc.WebRtcCallManager
 import im.vector.app.features.crypto.keysrequest.KeyRequestHandler
 import im.vector.app.features.crypto.verification.IncomingVerificationRequestHandler
@@ -75,11 +74,6 @@ class ActiveSessionHolder @Inject constructor(
         session.callSignalingService().addCallListener(callManager)
         imageManager.onSessionStarted(session)
         guardServiceStarter.start()
-        decryptionFailureTracker.currentModule = if (session.cryptoService().name() == "rust-sdk") {
-            Error.CryptoModule.Rust
-        } else {
-            Error.CryptoModule.Native
-        }
     }
 
     suspend fun clearActiveSession() {

vector/src/main/java/im/vector/app/features/analytics/DecryptionFailure.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.analytics
+
+import im.vector.app.features.analytics.plan.Error
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
+
+data class DecryptionFailure(
+        val timeStamp: Long,
+        val roomId: String,
+        val failedEventId: String,
+        val error: MXCryptoError,
+        val wasVisibleOnScreen: Boolean,
+        val ownIdentityTrustedAtTimeOfDecryptionFailure: Boolean,
+        // If this is set, it means that the event was decrypted but late. Will be -1 if
+        // the event was not decrypted after the maximum wait time.
+        val timeToDecryptMillis: Long? = null,
+        val isMatrixDotOrg: Boolean,
+        val isFederated: Boolean? = null,
+        val eventLocalAgeAtDecryptionFailure: Long? = null
+)
+
+fun DecryptionFailure.toAnalyticsEvent(): Error {
+    val errorMsg = (error as? MXCryptoError.Base)?.technicalMessage ?: error.message
+    return Error(
+            context = "mxc_crypto_error_type|${errorMsg}",
+            domain = Error.Domain.E2EE,
+            name = this.toAnalyticsErrorName(),
+            // this is deprecated keep for backward compatibility
+            cryptoModule = Error.CryptoModule.Rust,
+            cryptoSDK = Error.CryptoSDK.Rust,
+            eventLocalAgeMillis = eventLocalAgeAtDecryptionFailure?.toInt(),
+            isFederated = isFederated,
+            isMatrixDotOrg = isMatrixDotOrg,
+            timeToDecryptMillis = timeToDecryptMillis?.toInt() ?: -1,
+            wasVisibleToUser = wasVisibleOnScreen,
+            userTrustsOwnIdentity = ownIdentityTrustedAtTimeOfDecryptionFailure,
+    )
+}
+
+private fun DecryptionFailure.toAnalyticsErrorName(): Error.Name {
+    val error = this.error
+    val name = if (error is MXCryptoError.Base) {
+        when (error.errorType) {
+            MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID,
+            MXCryptoError.ErrorType.KEYS_WITHHELD         -> Error.Name.OlmKeysNotSentError
+            MXCryptoError.ErrorType.OLM                   -> Error.Name.OlmUnspecifiedError
+            MXCryptoError.ErrorType.UNKNOWN_MESSAGE_INDEX -> Error.Name.OlmIndexError
+            else                                          -> Error.Name.UnknownError
+        }
+    } else {
+        Error.Name.UnknownError
+    }
+    // check if it's an expected UTD!
+    val localAge = this.eventLocalAgeAtDecryptionFailure
+    val isHistorical = localAge != null && localAge < 0
+    if (isHistorical && !this.ownIdentityTrustedAtTimeOfDecryptionFailure) {
+        return Error.Name.HistoricalMessage
+    }
+
+    return name
+}