react-native-mytatva-rn-sdk 1.2.95 → 1.2.97

package/android/src/main/java/com/mytatvarnsdk/CgmTrackyLibModule.kt

@@ -1,5 +1,4 @@
-​package com.mytatvarnsdk
-
+package com.mytatvarnsdk
 import android.app.Application
 import android.bluetooth.BluetoothAdapter
 import android.content.Intent
@@ -283,6 +282,63 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /** SDK `latestGlucose` observer telemetry — must never throw or block queue/upload. */
+    private fun logSdkGlucoseReceivedSafely(pocGlucose: PocGlucose) {
+        try {
+            safeLogModuleEvent {
+                val activeSensorId = try {
+                    prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
+                } catch (_: Throwable) {
+                    ""
+                }
+                val pocJson = try {
+                    Gson().toJson(pocGlucose)
+                } catch (_: Throwable) {
+                    try {
+                        pocGlucose.toString()
+                    } catch (_: Throwable) {
+                        ""
+                    }
+                }
+                val attributes = try {
+                    mapOf(
+                        "glucoseId" to safePocField { pocGlucose.glucoseId?.toString() ?: "" },
+                        "activeSensorId" to activeSensorId,
+                        "timeInMillis" to safePocField { pocGlucose.timeInMillis.toString() },
+                        "showGlucoseMG" to safePocField { pocGlucose.showGlucoseMG.toString() },
+                        "showGlucose" to safePocField { pocGlucose.showGlucose.toString() },
+                        "deviceId" to safePocField { pocGlucose.deviceId?.toString() ?: "" },
+                        "errorCode" to safePocField { pocGlucose.errorCode?.toString() ?: "" },
+                        "name" to safePocField { pocGlucose.name ?: "" }
+                    )
+                } catch (_: Throwable) {
+                    emptyMap()
+                }
+                val message = try {
+                    "SDK latestGlucose received | glucoseId=${pocGlucose.glucoseId ?: ""} | showGlucoseMG=${pocGlucose.showGlucoseMG} | activeSensorId=$activeSensorId"
+                } catch (_: Throwable) {
+                    "SDK latestGlucose received"
+                }
+                logModuleEvent(
+                    where = "observeGlucoseData.sdkGlucoseReceived",
+                    message = message,
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = pocJson,
+                    attributes = attributes
+                )
+            }
+        } catch (_: Throwable) {
+            // Observer callback must always continue to queue/upload.
+        }
+    }
+
+    private inline fun safePocField(block: () -> String): String =
+        try {
+            block()
+        } catch (_: Throwable) {
+            ""
+        }
+
     private fun cgmStatusDeviceAttributes(
         status: String,
         device: PocDevice?,
@@ -744,6 +800,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         return@Observer
                     }
 
+                    logSdkGlucoseReceivedSafely(pocGlucose)
+
                     // Check for duplicate using glucoseId instead of timestamp
                     val glucoseId = pocGlucose.glucoseId ?: run {
                         Log.w("observeGlucoseData", "Glucose ID is null, skipping")

package/android/src/main/java/com/mytatvarnsdk/MainApplication.kt

@@ -19,7 +19,7 @@ class MainApplication : BApplication(), ReactApplication {
     MultiDex.install(base)
   }
 
-  private val mReactNativeHost = object : DefaultReactNativeHost(this) {
+  override val reactNativeHost: ReactNativeHost = object : DefaultReactNativeHost(this) {
     override fun getUseDeveloperSupport(): Boolean {
       return BuildConfig.DEBUG
     }
@@ -42,8 +42,4 @@ class MainApplication : BApplication(), ReactApplication {
 //    BleService.startService(this)
 //    BSharedPreferences.init(this)
   }
-
-  override fun getReactNativeHost(): ReactNativeHost {
-    return mReactNativeHost
-  }
 }

package/android/src/main/java/com/mytatvarnsdk/activity/ConnectSensorActivity.kt

@@ -42,6 +42,9 @@ import com.mytatvarnsdk.myView.progress.ProgressManagement
 import com.mytatvarnsdk.myView.progress.ProgressType
 import com.mytatvarnsdk.network.AuthenticateSDKService
 import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -139,6 +142,21 @@ class ConnectSensorActivity : BaseBleActivity() {
     fun manageErrorState(showError: Boolean, errorStatus: String) {
         ProgressManagement.getInstance().dismissWait(this)
         if (showError) {
+            if (errorStatus.isNotEmpty()) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "ConnectSensorActivity.error",
+                        message = "CGM journey error | screen=${javaClass.simpleName} | $errorStatus",
+                        level = SentryLogLevel.WARN,
+                        attributes = mapOf(
+                            "error_message" to errorStatus,
+                            "screen" to javaClass.simpleName,
+                            "is_reconnect" to isForReconnect.toString(),
+                        ),
+                        logsOnly = true,
+                    )
+                }
+            }
             binding.clFail.visibility = View.VISIBLE
             binding.clMain.visibility = View.GONE
             binding.commonButton.root.visibility = View.GONE
@@ -299,6 +317,20 @@ class ConnectSensorActivity : BaseBleActivity() {
         if (requestCode == REQUEST_QR && resultCode == RESULT_OK && data != null) {
             val device: PocDevice? = data.getParcelableExtra("device")
             if (device != null) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "cgmJourney.cgm_qr_activity_result_ok",
+                        message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_qr_activity_result_ok",
+                        level = SentryLogLevel.INFO,
+                        attributes = mapOf(
+                            "journey_step" to "cgm_qr_activity_result_ok",
+                            "screen" to javaClass.simpleName,
+                            "is_reconnect" to isForReconnect.toString(),
+                            "transmitter_name" to (device.name ?: ""),
+                        ),
+                        logsOnly = true,
+                    )
+                }
                 val lastConnectCgm = CgmTrackyLibModule.lastConnectCgm
                 Log.d("ConnectSensor", "lastConnectCgm: $lastConnectCgm")
 
@@ -337,6 +369,17 @@ class ConnectSensorActivity : BaseBleActivity() {
             val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
             val authenticateSDKService = AuthenticateSDKService(scope = scope)
 
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "ConnectSensorActivity.verifyDevice.request",
+                    message = "Diasens device verification request | sensorId=$scannedSensorId",
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = """{"sensorId":"$scannedSensorId","deviceType":"CGM","vendor":"diasens"}""",
+                    attributes = mapOf("sensor_id" to scannedSensorId),
+                    logsOnly = true,
+                )
+            }
+
             authenticateSDKService.verifyDevice(
                 environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                 token = token,
@@ -345,6 +388,16 @@ class ConnectSensorActivity : BaseBleActivity() {
                     override fun onResponseSuccess(response: String) {
                         try {
                             Log.d("ConnectSensor", "Device verification API response: $response")
+                            safeLogModuleEvent {
+                                logModuleEvent(
+                                    where = "ConnectSensorActivity.verifyDevice.success",
+                                    message = "Diasens device verification response",
+                                    level = SentryLogLevel.INFO,
+                                    jsonPayload = "response=$response",
+                                    attributes = mapOf("sensor_id" to scannedSensorId),
+                                    logsOnly = true,
+                                )
+                            }
 
                             val verificationResponse = Gson().fromJson(response, DeviceVerificationResponse::class.java)
                             val code = when (val rawCode = verificationResponse.code) {
@@ -375,6 +428,21 @@ class ConnectSensorActivity : BaseBleActivity() {
                             }
                         } catch (e: Exception) {
                             Log.e("ConnectSensor", "Error parsing device verification response: ${e.message}")
+                            safeLogModuleEvent {
+                                val errorMessage = e.message ?: "Failed to parse verification response"
+                                logModuleEvent(
+                                    where = "ConnectSensorActivity.verifyDevice.parseError",
+                                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                                    level = SentryLogLevel.WARN,
+                                    throwable = e,
+                                    attributes = mapOf(
+                                        "error_message" to errorMessage,
+                                        "screen" to javaClass.simpleName,
+                                        "is_reconnect" to isForReconnect.toString(),
+                                    ),
+                                    logsOnly = true,
+                                )
+                            }
                             runOnUiThread {
                                 ProgressManagement.getInstance().dismissWait(this@ConnectSensorActivity)
                                 manageErrorState(true, "Try Again")
@@ -382,23 +450,66 @@ class ConnectSensorActivity : BaseBleActivity() {
                         }
                     }
 
-                    override fun onResponseFail() {
-                        Log.e("ConnectSensor", "Device verification API call failed")
-                        runOnUiThread {
-                            ProgressManagement.getInstance().dismissWait(this@ConnectSensorActivity)
-                            manageErrorState(true, "Try Again")
+                        override fun onResponseFail() {
+                            Log.e("ConnectSensor", "Device verification API call failed")
+                            safeLogModuleEvent {
+                                val errorMessage =
+                                    "Diasens device verification API failed | sensorId=$scannedSensorId"
+                                logModuleEvent(
+                                    where = "ConnectSensorActivity.verifyDevice.fail",
+                                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                                    level = SentryLogLevel.WARN,
+                                    attributes = mapOf(
+                                        "error_message" to errorMessage,
+                                        "screen" to javaClass.simpleName,
+                                        "is_reconnect" to isForReconnect.toString(),
+                                    ),
+                                    logsOnly = true,
+                                )
+                            }
+                            runOnUiThread {
+                                ProgressManagement.getInstance().dismissWait(this@ConnectSensorActivity)
+                                manageErrorState(true, "Try Again")
+                            }
                         }
                     }
-                }
             )
         } catch (e: Exception) {
             Log.e("ConnectSensor", "Error validating diasens sensor: ${e.message}")
+            safeLogModuleEvent {
+                val errorMessage = e.message ?: "Diasens validation exception"
+                logModuleEvent(
+                    where = "ConnectSensorActivity.validateDiasensSensor",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                    level = SentryLogLevel.WARN,
+                    throwable = e,
+                    attributes = mapOf(
+                        "error_message" to errorMessage,
+                        "screen" to javaClass.simpleName,
+                        "is_reconnect" to isForReconnect.toString(),
+                    ),
+                    logsOnly = true,
+                )
+            }
             ProgressManagement.getInstance().dismissWait(this)
             manageErrorState(true, "Try Again")
         }
     }
 
     private fun manageDeviceVerificationError(message: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "ConnectSensorActivity.deviceVerificationError",
+                message = "CGM journey error | screen=${javaClass.simpleName} | $message",
+                level = SentryLogLevel.WARN,
+                attributes = mapOf(
+                    "error_message" to message,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         ProgressManagement.getInstance().dismissWait(this)
         binding.clFail.visibility = View.VISIBLE
         binding.clMain.visibility = View.GONE
@@ -454,6 +565,21 @@ class ConnectSensorActivity : BaseBleActivity() {
             }
         } catch (e: Exception) {
             Log.d("bind::-> ", "bind: ${e.message}")
+            safeLogModuleEvent {
+                val errorMessage = e.message ?: "Sensor bind exception"
+                logModuleEvent(
+                    where = "ConnectSensorActivity.bind",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                    level = SentryLogLevel.WARN,
+                    throwable = e,
+                    attributes = mapOf(
+                        "error_message" to errorMessage,
+                        "screen" to javaClass.simpleName,
+                        "is_reconnect" to isForReconnect.toString(),
+                    ),
+                    logsOnly = true,
+                )
+            }
         }
     }
 
@@ -482,6 +608,20 @@ class ConnectSensorActivity : BaseBleActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance

package/android/src/main/java/com/mytatvarnsdk/activity/PermissionActivity.kt

@@ -39,6 +39,9 @@ import com.mytatvarnsdk.base.BasePermissionActivity
 import com.mytatvarnsdk.databinding.ActivityPermissionBinding
 import com.mytatvarnsdk.databinding.BluetoothDialogBottomsheetBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 import org.json.JSONObject
 
 class PermissionActivity : BasePermissionActivity() {
@@ -202,6 +205,20 @@ class PermissionActivity : BasePermissionActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance
@@ -643,12 +660,38 @@ class PermissionActivity : BasePermissionActivity() {
     }
 
     private fun onLocationPermissionGranted() {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.cgm_location_permission_granted",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_location_permission_granted",
+                level = SentryLogLevel.INFO,
+                attributes = mapOf(
+                    "journey_step" to "cgm_location_permission_granted",
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         setSwitchChecked(binding.switchLocation, true)
         updateProceedButtonState()
     }
 
     @RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
     private fun onBluetoothPermissionGranted() {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.cgm_bluetooth_permission_granted",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_bluetooth_permission_granted",
+                level = SentryLogLevel.INFO,
+                attributes = mapOf(
+                    "journey_step" to "cgm_bluetooth_permission_granted",
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (bluetoothAdapter == null) {
             Toast.makeText(this, "Bluetooth not supported", Toast.LENGTH_SHORT).show()
         } else {

package/android/src/main/java/com/mytatvarnsdk/activity/PlaceSensorActivity.kt

@@ -25,6 +25,9 @@ import com.mytatvarnsdk.CgmTrackyLibModule
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivityPlaceSensorBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 
 class PlaceSensorActivity : AppCompatActivity() {
     private lateinit var binding: ActivityPlaceSensorBinding
@@ -99,6 +102,20 @@ class PlaceSensorActivity : AppCompatActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance

package/android/src/main/java/com/mytatvarnsdk/activity/PlaceTransmitterActivity.kt

@@ -25,6 +25,9 @@ import com.mytatvarnsdk.CgmTrackyLibModule
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivityPlaceTransmitterBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 
 class PlaceTransmitterActivity : AppCompatActivity() {
     private lateinit var binding: ActivityPlaceTransmitterBinding
@@ -136,6 +139,20 @@ class PlaceTransmitterActivity : AppCompatActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance

package/android/src/main/java/com/mytatvarnsdk/activity/QRActivity.kt

@@ -15,6 +15,9 @@ import cgmblelib.utils.SharedPreferencesLibraryUtil
 import com.myc.library_zxing.QRFragment
 import com.myc.library_zxing.view.OnFragmentListener
 import com.mytatvarnsdk.R
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 import ist.com.sdk.AlgorithmTools
 import ist.com.sdk.KRDecodeData
 
@@ -28,6 +31,18 @@ class QRActivity : AppCompatActivity(), View.OnClickListener {
         findViewById<View?>(R.id.btnLeft).setOnClickListener(this)
         mPocDevice = intent.getParcelableExtra("device")
         if (mPocDevice == null) {
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "QRActivity.missingDevice",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | QR scan started without transmitter device",
+                    level = SentryLogLevel.WARN,
+                    attributes = mapOf(
+                        "error_message" to "QR scan started without transmitter device",
+                        "screen" to javaClass.simpleName,
+                    ),
+                    logsOnly = true,
+                )
+            }
             finish()
         }
     }
@@ -36,9 +51,41 @@ class QRActivity : AppCompatActivity(), View.OnClickListener {
         super.onResume()
         mQRFragment = QRFragment.newInstance(object : OnFragmentListener {
             override fun onPermissionRequestFail(isForever: Boolean) {
+                val errorMessage = if (isForever) {
+                    "Camera permission denied permanently"
+                } else {
+                    "Camera permission denied"
+                }
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "QRActivity.cameraPermissionDenied",
+                        message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                        level = SentryLogLevel.WARN,
+                        attributes = mapOf(
+                            "error_message" to errorMessage,
+                            "screen" to javaClass.simpleName,
+                            "permission_denied_forever" to isForever.toString(),
+                        ),
+                        logsOnly = true,
+                    )
+                }
             }
 
             override fun onCameraOpenError(e: Exception?) {
+                val errorMessage = e?.message ?: "Camera failed to open"
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "QRActivity.cameraOpenError",
+                        message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                        level = SentryLogLevel.WARN,
+                        throwable = e,
+                        attributes = mapOf(
+                            "error_message" to errorMessage,
+                            "screen" to javaClass.simpleName,
+                        ),
+                        logsOnly = true,
+                    )
+                }
             }
 
             override fun onScanResult(messages: String?, bitmap: Bitmap?) {
@@ -71,12 +118,47 @@ class QRActivity : AppCompatActivity(), View.OnClickListener {
      */
     private fun decodeMessageCt3(message: String) {
         Log.d("QR Info ==> ", "decodeMessageCt3: $message")
+        try {
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "cgmJourney.cgm_qr_scanned",
+                    message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_qr_scanned",
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = message,
+                    attributes = mapOf(
+                        "journey_step" to "cgm_qr_scanned",
+                        "screen" to javaClass.simpleName,
+                    ),
+                    logsOnly = true,
+                )
+            }
 
-        val decodeData: KRDecodeData = AlgorithmTools.getInstance().decodeCT(message.toCharArray())
+            val decodeData: KRDecodeData = AlgorithmTools.getInstance().decodeCT(message.toCharArray())
 
-        Log.d("QR Info ==> ", "decodeData: $decodeData")
+            Log.d("QR Info ==> ", "decodeData: $decodeData")
 
-        showMessage(message, decodeData.k, decodeData.r, message)
+            showMessage(message, decodeData.k, decodeData.r, message)
+        } catch (e: Exception) {
+            val errorMessage = e.message ?: "QR decode failed"
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "QRActivity.decodeMessageCt3",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                    level = SentryLogLevel.WARN,
+                    throwable = e,
+                    attributes = mapOf(
+                        "error_message" to errorMessage,
+                        "screen" to javaClass.simpleName,
+                        "qr_raw" to message,
+                    ),
+                    logsOnly = true,
+                )
+            }
+            try {
+                mQRFragment?.restartPreviewAfterDelay(0)
+            } catch (_: Throwable) {
+            }
+        }
     }
 
     fun showMessage(message: String?, k: Float, r: Float, sensorInfo: String?) {
@@ -87,20 +169,79 @@ class QRActivity : AppCompatActivity(), View.OnClickListener {
             val qrInformation: QRInformation? = prefsHelper.qrInformation
 
             Log.d("qrInformation==> ", "mPocDevice:  ${mPocDevice.toString()}")
-            if (qrInformation != null && qrInformation.isEffective(mPocDevice?.name, r, k)) {
+            val isEffective = qrInformation?.isEffective(mPocDevice?.name, r, k) ?: false
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "cgmJourney.cgm_qr_is_effective",
+                    message = "CGM journey | screen=${javaClass.simpleName} | isEffective=$isEffective",
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = isEffective.toString(),
+                    attributes = mapOf(
+                        "journey_step" to "cgm_qr_is_effective",
+                        "screen" to javaClass.simpleName,
+                        "is_effective" to isEffective.toString(),
+                    ),
+                    logsOnly = true,
+                )
+            }
+            if (isEffective && qrInformation != null) {
                 Log.d("qrInformation==> ", "qrInformation:  $qrInformation")
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "cgmJourney.cgm_qr_validation_success",
+                        message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_qr_validation_success",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = qrInformation.toString(),
+                        attributes = mapOf(
+                            "journey_step" to "cgm_qr_validation_success",
+                            "screen" to javaClass.simpleName,
+                            "transmitter_name" to (mPocDevice?.name ?: ""),
+                            "sensor_id" to (qrInformation.sensor ?: ""),
+                        ),
+                        logsOnly = true,
+                    )
+                }
                 setResult(RESULT_OK, Intent().putExtra("device", mPocDevice as Parcelable))
                 finish()
             } else {
+                val failMessage = getString(R.string.verification_fail)
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "QRActivity.qrValidationFailed",
+                        message = "CGM journey error | screen=${javaClass.simpleName} | $failMessage",
+                        level = SentryLogLevel.WARN,
+                        attributes = mapOf(
+                            "error_message" to failMessage,
+                            "screen" to javaClass.simpleName,
+                            "transmitter_name" to (mPocDevice?.name ?: ""),
+                            "qr_raw" to (message ?: ""),
+                        ),
+                        logsOnly = true,
+                    )
+                }
                 Toast.makeText(
                     this@QRActivity,
-                    getString(R.string.verification_fail),
+                    failMessage,
                     Toast.LENGTH_SHORT
                 )
                     .show()
                 mQRFragment!!.restartPreviewAfterDelay(0)
             }
         } catch (e: Exception) {
+            val errorMessage = e.message ?: "QR validation exception"
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "QRActivity.showMessage",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                    level = SentryLogLevel.WARN,
+                    throwable = e,
+                    attributes = mapOf(
+                        "error_message" to errorMessage,
+                        "screen" to javaClass.simpleName,
+                    ),
+                    logsOnly = true,
+                )
+            }
             e.printStackTrace()
             finish()
         }

package/android/src/main/java/com/mytatvarnsdk/activity/SearchTransmitterActivity.kt

@@ -52,6 +52,9 @@ import com.mytatvarnsdk.myView.dialog.WarnDialogUtils
 import com.mytatvarnsdk.myView.progress.ProgressManagement
 import com.mytatvarnsdk.myView.progress.ProgressType
 import com.mytatvarnsdk.network.AuthenticateSDKService
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -127,6 +130,21 @@ class SearchTransmitterActivity : BaseBleActivity() {
 
     fun manageErrorState(showError: Boolean, errorStatus: String) {
         if (showError) {
+            if (errorStatus.isNotEmpty()) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "SearchTransmitterActivity.error",
+                        message = "CGM journey error | screen=${javaClass.simpleName} | $errorStatus",
+                        level = SentryLogLevel.WARN,
+                        attributes = mapOf(
+                            "error_message" to errorStatus,
+                            "screen" to javaClass.simpleName,
+                            "is_reconnect" to isForReconnect.toString(),
+                        ),
+                        logsOnly = true,
+                    )
+                }
+            }
             binding.clFail.visibility = View.VISIBLE
             binding.clMain.visibility = View.GONE
             binding.commonButton.root.visibility = View.GONE
@@ -296,11 +314,37 @@ class SearchTransmitterActivity : BaseBleActivity() {
 
     public override fun checkFailForLowPower() {
         ProgressManagement.getInstance().dismissWait(this)
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "SearchTransmitterActivity.checkFailForLowPower",
+                message = "CGM journey error | screen=${javaClass.simpleName} | Transmitter low power",
+                level = SentryLogLevel.WARN,
+                attributes = mapOf(
+                    "error_message" to "Transmitter low power",
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         WarnDialogUtils.getInstance().showWarnDialog(this, DialogType.TYPE_LOW_POWER)
     }
 
     public override fun checkFailErrorTemperature() {
         ProgressManagement.getInstance().dismissWait(this)
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "SearchTransmitterActivity.checkFailErrorTemperature",
+                message = "CGM journey error | screen=${javaClass.simpleName} | Transmitter temperature error",
+                level = SentryLogLevel.WARN,
+                attributes = mapOf(
+                    "error_message" to "Transmitter temperature error",
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
     }
 
     public override fun onlineLost() {
@@ -318,6 +362,21 @@ class SearchTransmitterActivity : BaseBleActivity() {
             }
         } catch (e: Exception) {
             Log.d("bind::-> ", "bind: ${e.message}")
+            safeLogModuleEvent {
+                val errorMessage = e.message ?: "Transmitter bind exception"
+                logModuleEvent(
+                    where = "SearchTransmitterActivity.bind",
+                    message = "CGM journey error | screen=${javaClass.simpleName} | $errorMessage",
+                    level = SentryLogLevel.WARN,
+                    throwable = e,
+                    attributes = mapOf(
+                        "error_message" to errorMessage,
+                        "screen" to javaClass.simpleName,
+                        "is_reconnect" to isForReconnect.toString(),
+                    ),
+                    logsOnly = true,
+                )
+            }
         }
     }
 
@@ -440,6 +499,20 @@ class SearchTransmitterActivity : BaseBleActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance
@@ -487,6 +560,19 @@ class SearchTransmitterActivity : BaseBleActivity() {
     }
 
     private fun startDeviceSearch() {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.cgm_transmitter_scan_started",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_transmitter_scan_started",
+                level = SentryLogLevel.INFO,
+                attributes = mapOf(
+                    "journey_step" to "cgm_transmitter_scan_started",
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         mModel = ViewModelProviders.of(this)[MainActivityModel::class.java]
 
         ReconnectManagement.getInstance()
@@ -544,6 +630,20 @@ class SearchTransmitterActivity : BaseBleActivity() {
         isTransmitterConnected = true
 
         if (transmitterDeviceInfo != null) {
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "cgmJourney.cgm_transmitter_connect_clicked",
+                    message = "CGM journey | screen=${javaClass.simpleName} | step=cgm_transmitter_connect_clicked",
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = transmitterDeviceInfo?.pocDevice?.name ?: "",
+                    attributes = mapOf(
+                        "journey_step" to "cgm_transmitter_connect_clicked",
+                        "screen" to javaClass.simpleName,
+                        "is_reconnect" to isForReconnect.toString(),
+                    ),
+                    logsOnly = true,
+                )
+            }
             if (isForReconnect) {
                 GattTool.unBindInDatabase(this, enumUnBind.UNBIND_FORCE)
             }

package/android/src/main/java/com/mytatvarnsdk/activity/SensorConnectSuccessActivity.kt

@@ -31,6 +31,9 @@ import com.mytatvarnsdk.network.AuthenticateSDKService
 import com.mytatvarnsdk.network.AuthenticateSDKService.LoaderListener
 import com.mytatvarnsdk.utils.DeviceStatus
 import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -121,6 +124,20 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance
@@ -173,6 +190,20 @@ class SensorConnectSuccessActivity : AppCompatActivity() {
         obj.put("status", DeviceStatus.CONNECTED.id)
         obj.put("rawData", rawData)
 
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "SensorConnectSuccessActivity.postDeviceData.request",
+                message = "POST /cgm/connection CONNECTED on sensor success screen",
+                level = SentryLogLevel.INFO,
+                jsonPayload = "request=${obj}",
+                attributes = mapOf(
+                    "cgm_status" to DeviceStatus.CONNECTED.id,
+                    "sensor_id" to (information.sensor ?: ""),
+                ),
+                logsOnly = true,
+            )
+        }
+
         authenticateSDKService.postDeviceData(
             environment = if (CgmTrackyLibModule.env.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
             data = obj.toString(),

package/android/src/main/java/com/mytatvarnsdk/activity/StartCGMActivity.kt

@@ -28,6 +28,9 @@ import com.mytatvarnsdk.CgmTrackyLibModule.Companion.mReactContext
 import com.mytatvarnsdk.R
 import com.mytatvarnsdk.databinding.ActivityStartCgmactivityBinding
 import com.mytatvarnsdk.databinding.ExitDialogBottomsheetBinding
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
+import io.sentry.SentryLogLevel
 
 
 class StartCGMActivity : AppCompatActivity() {
@@ -168,6 +171,20 @@ class StartCGMActivity : AppCompatActivity() {
     }
 
     private fun sendDataToRN(data: String, status: String) {
+        safeLogModuleEvent {
+            logModuleEvent(
+                where = "cgmJourney.$status",
+                message = "CGM journey | screen=${javaClass.simpleName} | step=$status",
+                level = SentryLogLevel.INFO,
+                jsonPayload = data.takeIf { it.isNotEmpty() },
+                attributes = mapOf(
+                    "journey_step" to status,
+                    "screen" to javaClass.simpleName,
+                    "is_reconnect" to isForReconnect.toString(),
+                ),
+                logsOnly = true,
+            )
+        }
         if (reactContext != null) {
             try {
                 val catalystInstance: CatalystInstance = reactContext.catalystInstance

package/android/src/main/java/com/mytatvarnsdk/network/AuthenticateSDKService.kt

@@ -1,12 +1,15 @@
 package com.mytatvarnsdk.network
 
 import android.util.Log
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.logModuleEvent
+import com.mytatvarnsdk.utils.CgmModuleSentryLog.safeLogModuleEvent
 import com.mytatvarnsdk.utils.EncryptionUtil.getDecryptedData
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptedText
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptionIv
 import com.mytatvarnsdk.utils.EncryptionUtil.getEncryptionKey
 import com.mytatvarnsdk.utils.RetrofitInstance
 import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import io.sentry.SentryLogLevel
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_API_KEY
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_BASE_URL
 import com.mytatvarnsdk.utils.TatvaEncryptionConfig.PROD_ENC_IV
@@ -159,7 +162,29 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
 
                 Log.d("API Response", "API response: $decryptedResponse")
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.success",
+                        message = "POST /cgm/connection succeeded",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = "request=$data | response=$decryptedResponse",
+                        attributes = mapOf("endpoint" to "/cgm/connection"),
+                        logsOnly = true,
+                    )
+                }
+
             } catch (e: HttpException) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.httpError",
+                        message = "POST /cgm/connection HTTP ${e.code()}",
+                        level = SentryLogLevel.WARN,
+                        jsonPayload = "request=$data",
+                        throwable = e,
+                        attributes = mapOf("http_code" to e.code().toString()),
+                        logsOnly = true,
+                    )
+                }
                 if (e.code() == 401) {
                     Log.d("API Error", "401 Unauthorized - Token: $token")
                     // Further handling if necessary
@@ -167,6 +192,17 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
                     throw e
                 }
             } catch (e: Exception) {
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.postDeviceData.fail",
+                        message = "POST /cgm/connection failed",
+                        level = SentryLogLevel.WARN,
+                        jsonPayload = "request=$data",
+                        throwable = e,
+                        attributes = mapOf("endpoint" to "/cgm/connection"),
+                        logsOnly = true,
+                    )
+                }
                 e.printStackTrace()
                 Log.d("API Response", "Exception: ${e.message}")
             } finally {
@@ -267,8 +303,35 @@ class AuthenticateSDKService(val scope: CoroutineScope) {
 
                 Log.d("API Response", "Device Verification API Response: $decryptedResponse")
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.verifyDevice.success",
+                        message = "GET device_verification succeeded | sensorId=$sensorId",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = "response=$decryptedResponse",
+                        attributes = mapOf("sensor_id" to sensorId),
+                        logsOnly = true,
+                    )
+                }
+
                 responseListener.onResponseSuccess(decryptedResponse)
             } catch (e: Exception) {
+                safeLogModuleEvent {
+                    val errorMessage =
+                        e.message ?: "GET device_verification failed | sensorId=$sensorId"
+                    logModuleEvent(
+                        where = "AuthenticateSDKService.verifyDevice.fail",
+                        message = "CGM journey error | screen=AuthenticateSDKService | $errorMessage",
+                        level = SentryLogLevel.WARN,
+                        throwable = e,
+                        attributes = mapOf(
+                            "error_message" to errorMessage,
+                            "screen" to "AuthenticateSDKService",
+                            "sensor_id" to sensorId,
+                        ),
+                        logsOnly = true,
+                    )
+                }
                 responseListener.onResponseFail()
                 e.printStackTrace()
                 Log.d("API Response", "Device Verification Exception: ${e.message}")

package/android/src/main/java/com/mytatvarnsdk/utils/CgmModuleSentryLog.kt

@@ -0,0 +1,205 @@
+package com.mytatvarnsdk.utils
+
+import android.util.Log
+import com.mytatvarnsdk.CgmTrackyLibModule
+import io.sentry.ScopeCallback
+import io.sentry.Sentry
+import io.sentry.SentryAttributes
+import io.sentry.SentryLevel
+import io.sentry.SentryLogLevel
+import io.sentry.logger.SentryLogParameters
+
+/**
+ * Shared Sentry logging for [com.mytatvarnsdk.CgmTrackyLibModule] and journey activities.
+ *
+ * Use:
+ * ```
+ * safeLogModuleEvent {
+ *     logModuleEvent("MyLocation", message = "...", level = SentryLogLevel.INFO)
+ * }
+ * ```
+ *
+ * Never throws — CGM flows must continue if logging fails.
+ */
+object CgmModuleSentryLog {
+    private const val MAX_SENTRY_DATA_EXTRA_CHARS = 16_384
+    private const val MAX_SENTRY_MESSAGE_DATA_CHARS = 2_000
+
+    private fun clipForSentry(text: String, maxChars: Int = MAX_SENTRY_DATA_EXTRA_CHARS): String =
+        try {
+            if (text.length <= maxChars) text else text.take(maxChars) + "…"
+        } catch (_: Throwable) {
+            ""
+        }
+
+    /** Wraps log preparation + emission so a bad payload cannot break CGM flows. */
+    inline fun safeLogModuleEvent(block: () -> Unit) {
+        try {
+            block()
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Failed to prepare Sentry log: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    /**
+     * Structured Sentry log (like RN `Sentry.logger.info/warn/error`).
+     * Uses the host app's Sentry client (never call Sentry.init here).
+     *
+     * @param logsOnly When true, writes to Sentry Logs only — never creates Issues
+     *   (use for journey QR/bind/scan errors shown to the user).
+     */
+    fun logModuleEvent(
+        where: String,
+        message: String = "",
+        level: SentryLogLevel = SentryLogLevel.INFO,
+        jsonPayload: String? = null,
+        throwable: Throwable? = null,
+        attributes: Map<String, String> = emptyMap(),
+        logsOnly: Boolean = false,
+    ) {
+        try {
+            if (!Sentry.isEnabled()) {
+                Log.w("logModuleEvent", "Sentry not initialized — skipping [$where]")
+                return
+            }
+
+            val resolvedMessage = when {
+                message.isNotEmpty() -> message
+                throwable != null -> {
+                    val typeName = throwable.javaClass.simpleName ?: "Throwable"
+                    "$typeName: ${throwable.message ?: ""}"
+                }
+                else -> where
+            }
+            val mergedAttributes = try {
+                attributes.toMutableMap()
+            } catch (_: Throwable) {
+                mutableMapOf()
+            }
+            throwable?.let {
+                mergedAttributes["exception"] = it.javaClass.simpleName ?: "Throwable"
+                mergedAttributes["exception_message"] = it.message ?: ""
+            }
+
+            val clippedJson = jsonPayload?.let { clipForSentry(it) }
+            val logMessage = clipForSentry(
+                "CgmTrackyLib: $where | $resolvedMessage",
+                MAX_SENTRY_MESSAGE_DATA_CHARS
+            )
+
+            val env = CgmTrackyLibModule.env
+            val sentryAttributes = mutableMapOf<String, Any>(
+                "cgm_tracky_lib" to "true",
+                "location" to where,
+            )
+            if (env.isNotEmpty()) {
+                sentryAttributes["tatva_env"] = env
+            }
+            clippedJson?.let { sentryAttributes["json"] = it }
+            mergedAttributes.forEach { (key, value) ->
+                try {
+                    sentryAttributes[key] = clipForSentry(value, 500)
+                } catch (_: Throwable) {
+                    sentryAttributes[key] = ""
+                }
+            }
+
+            val logsEnabled = try {
+                Sentry.getCurrentScopes()?.options?.logs?.isEnabled == true
+            } catch (_: Throwable) {
+                false
+            }
+
+            if (logsEnabled) {
+                val logParams = SentryLogParameters.create(
+                    SentryAttributes.fromMap(sentryAttributes)
+                )
+                logParams.origin = "cgm-tracky-lib"
+                Sentry.logger().log(level, logParams, logMessage)
+                if (!logsOnly && throwable != null && level >= SentryLogLevel.ERROR) {
+                    captureModuleException(where, throwable, sentryAttributes)
+                }
+            } else if (!logsOnly) {
+                captureModuleEventFallback(where, logMessage, level, throwable, sentryAttributes)
+            } else {
+                Log.w("logModuleEvent", "[$where] $logMessage (native Sentry Logs disabled)")
+            }
+        } catch (sentryEx: Throwable) {
+            try {
+                Log.w(
+                    "logModuleEvent",
+                    "Sentry logger failed for [$where]: ${sentryEx.message}",
+                    sentryEx
+                )
+                Log.e("CgmTrackyLib", "[$where]", throwable ?: sentryEx)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun mapLogLevelToEventLevel(level: SentryLogLevel): SentryLevel = when (level) {
+        SentryLogLevel.TRACE, SentryLogLevel.DEBUG -> SentryLevel.DEBUG
+        SentryLogLevel.INFO -> SentryLevel.INFO
+        SentryLogLevel.WARN -> SentryLevel.WARNING
+        SentryLogLevel.ERROR -> SentryLevel.ERROR
+        SentryLogLevel.FATAL -> SentryLevel.FATAL
+    }
+
+    private fun applyModuleScopeExtras(
+        where: String,
+        attributes: Map<String, Any>
+    ): ScopeCallback = ScopeCallback { scope ->
+        scope.setTag("cgm_tracky_lib", "true")
+        scope.setTag("location", where)
+        val env = CgmTrackyLibModule.env
+        if (env.isNotEmpty()) {
+            scope.setTag("tatva_env", env)
+        }
+        attributes.forEach { (key, value) ->
+            try {
+                scope.setExtra(key, value.toString())
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun captureModuleEventFallback(
+        where: String,
+        message: String,
+        level: SentryLogLevel,
+        throwable: Throwable?,
+        attributes: Map<String, Any>
+    ) {
+        try {
+            val scopeCallback = applyModuleScopeExtras(where, attributes)
+            if (throwable != null) {
+                Sentry.captureException(throwable, scopeCallback)
+            } else {
+                Sentry.captureMessage(message, mapLogLevelToEventLevel(level), scopeCallback)
+            }
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Sentry fallback capture failed for [$where]: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun captureModuleException(
+        where: String,
+        throwable: Throwable,
+        attributes: Map<String, Any>
+    ) {
+        try {
+            Sentry.captureException(throwable, applyModuleScopeExtras(where, attributes))
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Sentry captureException failed for [$where]: ${t.message}", t)
+            } catch (_: Throwable) {
+            }
+        }
+    }
+}

package/android/src/main/java/com/mytatvarnsdk/utils/CgmSentryLog.kt

@@ -0,0 +1,28 @@
+package com.mytatvarnsdk.utils
+
+import io.sentry.SentryLogLevel
+
+/**
+ * Thin compatibility wrapper for [com.mytatvarnsdk.CgmTrackyLibModule] journey launch calls.
+ * Journey activities should use [CgmModuleSentryLog.safeLogModuleEvent] + [CgmModuleSentryLog.logModuleEvent] directly.
+ */
+object CgmSentryLog {
+    fun logJourneyLaunch(where: String, isReconnect: Boolean, envType: String) {
+        try {
+            CgmModuleSentryLog.safeLogModuleEvent {
+                CgmModuleSentryLog.logModuleEvent(
+                    where = where,
+                    message = "CGM journey launched | isReconnect=$isReconnect | env=$envType",
+                    level = SentryLogLevel.INFO,
+                    attributes = mapOf(
+                        "is_reconnect" to isReconnect.toString(),
+                        "env_type" to envType,
+                    ),
+                    logsOnly = true,
+                )
+            }
+        } catch (_: Throwable) {
+            // Never propagate — CGM launch must continue.
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mytatva-rn-sdk",
-  "version": "1.2.95",
+  "version": "1.2.97",
   "description": "a package to inject data into visit health pwa",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",