react-native-mytatva-rn-sdk 1.2.89 → 1.2.91

package/android/build.gradle

@@ -164,6 +164,10 @@ dependencies {
     //     Support library depends on this lightweight import
     implementation 'androidx.lifecycle:lifecycle-runtime:2.1.0'
 
+    // Sentry: uses host app's init (e.g. @sentry/react-native); only capture from native here
+    implementation platform('io.sentry:sentry-bom:7.14.0')
+    implementation 'io.sentry:sentry-android'
+
     // network
     implementation 'com.squareup.retrofit2:retrofit:2.9.0'
     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

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

@@ -44,6 +44,8 @@ import com.mytatvarnsdk.network.AuthenticateSDKService
 import com.mytatvarnsdk.network.AuthenticateSDKService.LoaderListener
 import com.mytatvarnsdk.utils.DeviceStatus
 import com.mytatvarnsdk.utils.TATVA_ENVIRONMENT
+import io.sentry.Sentry
+import io.sentry.SentryLevel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -102,12 +104,91 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         var userToken: String = ""
         var env: String = ""
         var lastConnectCgm: String = ""
+
+        // Sentry event message field is typically much smaller than "extra" fields.
+        // Keep JSON in extras as a full (clipped) payload, but also include a small prefix in the message
+        // so it's visible in the Sentry dashboard list/search.
+        private const val MAX_SENTRY_DATA_EXTRA_CHARS = 16_384
+        private const val MAX_SENTRY_MESSAGE_DATA_CHARS = 2_000
     }
 
     override fun getName(): String {
         return "CgmTrackyLib"
     }
 
+    /**
+     * Uses the host app's Sentry client (never call Sentry.init here).
+     * [data]: [Throwable] → exception event; anything else → message + extra `data` (stringified, clipped);
+     * null → error message with location only.
+     */
+    private fun captureModuleException(
+        where: String,
+        data: Any?,
+        level: SentryLevel = SentryLevel.ERROR
+    ) {
+        try {
+            Sentry.withScope { scope ->
+                scope.setTag("cgm_tracky_lib", "true")
+                scope.setExtra("location", where)
+                if (env.isNotEmpty()) {
+                    scope.setExtra("tatva_env", env)
+                }
+
+                when (data) {
+                    null ->
+                        run {
+                            Sentry.captureMessage("CgmTrackyLib: $where", level)
+                        }
+
+                    is Throwable ->
+                        run {
+                            // Put exception summary into `extra.data` for quick inspection.
+                            val throwableText =
+                                "${data.javaClass.simpleName}: ${data.message ?: ""}".trim()
+                            val clipped =
+                                if (throwableText.length > MAX_SENTRY_DATA_EXTRA_CHARS) {
+                                    throwableText.take(MAX_SENTRY_DATA_EXTRA_CHARS) + "…"
+                                } else {
+                                    throwableText
+                                }
+                            scope.setExtra("data", clipped)
+                            Sentry.captureException(data)
+                        }
+
+                    else -> {
+                        val text = when (data) {
+                            is String -> data
+                            else -> data.toString()
+                        }
+                        val clipped =
+                            if (text.length > MAX_SENTRY_DATA_EXTRA_CHARS) {
+                                text.take(MAX_SENTRY_DATA_EXTRA_CHARS) + "…"
+                            } else {
+                                text
+                            }
+                        scope.setExtra("data", clipped)
+                        // Duplicate under a more explicit key so it is easy to find in Sentry UI.
+                        scope.setExtra("json", clipped)
+
+                        // Also include a prefix in the message itself so it appears in the main event row.
+                        // (In some Sentry views, extra fields are not shown by default.)
+                        val messageData =
+                            if (clipped.length > MAX_SENTRY_MESSAGE_DATA_CHARS) {
+                                clipped.take(MAX_SENTRY_MESSAGE_DATA_CHARS) + "…"
+                            } else {
+                                clipped
+                            }
+
+                        Sentry.captureMessage("CgmTrackyLib: $where | data=$messageData", level)
+                    }
+                }
+            }
+        } catch (sentryEx: Exception) {
+            // If Sentry itself fails, never crash the CGM processing flow.
+            Log.e("captureModuleException", "Sentry capture failed: ${sentryEx.message}", sentryEx)
+        }
+    }
+
     private fun updateUserData(data: ReadableMap?) {
         currentUserData = data
         // Always reset so stale values from a previous user don't persist
@@ -121,7 +202,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
             }
         } catch (e: Exception) {
-            Log.e("updateUserData", "Error extracting last_connect_cgm: ${e.message}")
+            Log.e("updateUserData", "Error extracting last_connect_cgm: ${e.message}", e)
+            captureModuleException("updateUserData", e)
         }
     }
 
@@ -154,7 +236,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 deviceObserver?.let { mModel.device.observeForever(it) }
             }
         } catch (e: Exception) {
-            Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}")
+            Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}", e)
+            captureModuleException("observeDeviceStatus", e)
         }
     }
 
@@ -281,7 +364,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
             }
         } catch (e: Exception) {
-            Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}")
+            Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}", e)
+            captureModuleException("observeTransmitterUnbindStatus", e)
         }
     }
 
@@ -337,7 +421,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
 
             } catch (e: Exception) {
-                e.printStackTrace()
+                Log.e("postEventDataToAPI", "postEventDataToAPI: ${e.message}", e)
+                captureModuleException("postEventDataToAPI", e)
             }
         }
     }
@@ -403,7 +488,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             intent.putExtra("envType", env)
             currentActivity?.startActivity(intent)
         } catch (e: Exception) {
-            Log.e("startCgmTracky", "startCgmTracky: ${e.message}")
+            Log.e("startCgmTracky", "startCgmTracky: ${e.message}", e)
+            captureModuleException("startCgmTracky", e)
         }
     }
 
@@ -431,7 +517,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 ).putExtra("envType", env)
             )
         } catch (e: Exception) {
-            Log.e("reconnectCgmTracky", "reconnectCgmTracky: ${e.message}")
+            Log.e("reconnectCgmTracky", "reconnectCgmTracky: ${e.message}", e)
+            captureModuleException("reconnectCgmTracky", e)
         }
     }
 
@@ -441,7 +528,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             val intent = Intent(currentActivity, HelpActivity::class.java)
             currentActivity?.startActivity(intent)
         } catch (e: Exception) {
-            Log.e("openHelpSupport", "openHelpSupport: ${e.message}")
+            Log.e("openHelpSupport", "openHelpSupport: ${e.message}", e)
+            captureModuleException("openHelpSupport", e)
         }
     }
 
@@ -512,7 +600,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         isObserving = true
                         Log.d("observeGlucoseData", "Live glucose observer started successfully")
                     } catch (e: Exception) {
-                        Log.e("observeGlucoseData", "Error adding observer: ${e.message}")
+                        Log.e("observeGlucoseData", "Error adding observer: ${e.message}", e)
+                        captureModuleException("observeGlucoseData.observeForever", e)
                         glucoseObserver = null
                         isObserving = false
                     }
@@ -520,8 +609,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
         } catch (e: Exception) {
-            Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}")
-            e.printStackTrace()
+            Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}", e)
+            captureModuleException("observeGlucoseData", e)
             isObserving = false
             glucoseObserver = null
         }
@@ -586,7 +675,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
             Log.d("handleGlucoseData", "Processing glucose data: ${pocGlucose.glucoseId}")
-
             if (pocGlucose.errorCode == enumError.NONE) {
                 /* if (pocGlucose.showGlucoseMG > 0) { */
                 val dto: GlucoseLog = mapToDto(pocGlucose)
@@ -606,7 +694,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 val json = singlePayloadJsonObject.toString()
 
                 Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
-
+                // String → captureModuleException puts JSON in scope extra "data" (clipped); INFO avoids error-rate noise.
+                // captureModuleException("handleGlucoseData==>postCGMData", json, level = SentryLevel.INFO)
                 authenticateSDKService.postCGMData(
                     environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                     data = json,
@@ -614,10 +703,31 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     responseListener = object : AuthenticateSDKService.ResponseListener {
                         override fun onResponseSuccess(response: String) {
                             updateSyncMetadata(pocGlucose)
+                            // captureModuleException(
+                            //     "handleGlucoseData.postCGMData.success",
+                            //     json,
+                            //     extras =
+                            //         mapOf(
+                            //             "pocGlucose" to pocGlucose.toString(),
+                            //             "sdk_response" to response
+                            //         ),
+                            //     level = SentryLevel.INFO
+                            // )
                             Log.d("CGM Data", "Single glucose data uploaded successfully")
                         }
 
                         override fun onResponseFail() {
+                            val lastSync = prefsHelper?.lastSyncData
+                            val contextData =
+                                "failure_reason=Failed to upload single glucose data;" +
+                                        "pocGlucose=${pocGlucose};" +
+                                        "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                                        "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                            captureModuleException(
+                                "handleGlucoseData.postCGMData.fail",
+                                "$json | $contextData",
+                                level = SentryLevel.WARNING
+                            )
                             Log.e("CGM Data", "Failed to upload single glucose data")
                         }
                     }
@@ -631,11 +741,31 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                  } */
             } else {
                 Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
+                val lastSync = prefsHelper?.lastSyncData
+                val contextData =
+                    "failure_reason=Glucose data has error: ${pocGlucose.errorCode};" +
+                            "pocGlucose=${pocGlucose};" +
+                            "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                            "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                captureModuleException(
+                    "handleGlucoseData==>postCGMData",
+                    "Glucose data has error: ${pocGlucose.errorCode} | $contextData",
+                    level = SentryLevel.INFO
+                )
                 handleGlucoseError(pocGlucose, envType)
             }
         } catch (e: Exception) {
-            Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}")
-            e.printStackTrace()
+            Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}", e)
+            val lastSync = prefsHelper?.lastSyncData
+            val contextData =
+                "failure_reason=Exception in handleGlucoseData;" +
+                        "pocGlucose=${pocGlucose};" +
+                        "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                        "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+            captureModuleException(
+                "handleGlucoseData",
+                RuntimeException("handleGlucoseData failed | $contextData", e)
+            )
         }
     }
 
@@ -680,8 +810,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 )
             }
         } catch (e: Exception) {
-            Log.e("handleGlucoseError", "Error handling glucose error: ${e.message}")
-            e.printStackTrace()
+            Log.e("handleGlucoseError", "Error handling glucose error: ${e.message}", e)
+            captureModuleException("handleGlucoseError", e)
         }
     }
 
@@ -725,6 +855,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 val dataAge = if (lastSyncData != null) currentTime - lastSyncData.timeInMillis else 0L
 
                 if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
+            
                     val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
 
                     val glucoseCount = glucoseData?.size ?: 0
@@ -773,7 +904,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         }
                     }
                 } else {
-                    Log.d("observeAllGlucoseData", "ydgdfgf")
                     Log.d("observeAllGlucoseData", "Processing ${pendingData.size} pending items")
                     // No batch needed, but process pending data if any
                     if (pendingData.isNotEmpty()) {
@@ -794,6 +924,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
             } catch (e: Exception) {
                 Log.e("observeAllGlucoseData", "Error in batch processing: ${e.message}", e)
+                captureModuleException("observeAllGlucoseData", e)
             } finally {
                 // Always reset the flag
                 isBatchProcessing.set(false)
@@ -841,7 +972,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
         } catch (e: Exception) {
-            Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
+            Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}", e)
+            captureModuleException("processBatchDataAndStartObserver", e)
             // Start live observation even on error
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
@@ -860,7 +992,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             Log.d("dbFile======", dbFile.absolutePath)
             promise.resolve(dbFile.absolutePath)
         } catch (e: Exception) {
-            Log.d("dbFileerrrr======", "dbFileerrrr======")
+            Log.d("dbFileerrrr======", "dbFileerrrr======", e)
+            captureModuleException("getTrackLibDbPath", e)
             promise.reject("ERROR_DB_PATH", e)
         }
     }
@@ -890,7 +1023,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             prefsHelper?.clearQRInformation()
 
         } catch (e: Exception) {
-            Log.e("resetCgmState", "Error resetting CGM state: ${e.message}")
+            Log.e("resetCgmState", "Error resetting CGM state: ${e.message}", e)
+            captureModuleException("resetCgmState", e)
         }
     }
 
@@ -950,7 +1084,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             promise.resolve(resultArray)
 
         } catch (e: Exception) {
-            Log.e("getCgmLogFiles", "Error getting log files: ${e.message}")
+            Log.e("getCgmLogFiles", "Error getting log files: ${e.message}", e)
+            captureModuleException("getCgmLogFiles", e)
             promise.reject("ERROR_GET_LOG_FILES", e.message, e)
         }
     }
@@ -1093,10 +1228,38 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     lastSyncedRecord = batch.lastOrNull()
                     // Update sync metadata after each successful batch
                     updateSyncMetadata(lastSyncedRecord)
+                    // captureModuleException(
+                    //     "processBatchDataSynchronously.batchSuccess",
+                    //     json,
+                    //     extras =
+                    //         mapOf(
+                    //             "batchIndex" to index.toString(),
+                    //             "lastSyncedRecord" to (lastSyncedRecord?.toString() ?: "")
+                    //         ),
+                    //     level = SentryLevel.INFO
+                    // )
+
                     Log.d("Batch Upload", "✅ Batch $index uploaded and synced successfully")
                 } else {
                     allBatchesSuccessful = false
                     Log.e("Batch Upload", "❌ Batch $index failed")
+                    val lastSync = prefsHelper?.lastSyncData
+                    val contextData =
+                        "failure_reason=postCGMData returned failure;" +
+                                "batchIndex=$index;" +
+                                "batch_records=${batch.size};" +
+                                "payload_chars=${json.length};" +
+                                "first_glucoseId=${batch.firstOrNull()?.glucoseId ?: ""};" +
+                                "last_glucoseId=${batch.lastOrNull()?.glucoseId ?: ""};" +
+                                "first_timeInMillis=${batch.firstOrNull()?.timeInMillis ?: ""};" +
+                                "last_timeInMillis=${batch.lastOrNull()?.timeInMillis ?: ""};" +
+                                "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                                "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                    captureModuleException(
+                        "processBatchDataSynchronously.batchUploadFailed",
+                        "postCGMData returned failure for batch $index | $contextData",
+                        level = SentryLevel.WARNING
+                    )
                     // Continue with next batch instead of breaking (optional based on your needs)
                     // break
                 }
@@ -1105,7 +1268,14 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 delay(500L)
 
             } catch (e: Exception) {
-                Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
+                Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}", e)
+                captureModuleException(
+                    "processBatchDataSynchronously.batch",
+                    RuntimeException(
+                        "processBatchDataSynchronously.batch failed | batchIndex=$index",
+                        e
+                    )
+                )
                 allBatchesSuccessful = false
                 // Continue processing other batches
             }
@@ -1149,7 +1319,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     deviceObserver?.let { mModel.device.removeObserver(it) }
                     Log.d("stopObservingGlucoseData", "Device observer removed successfully")
                 } catch (e: Exception) {
-                    Log.e("stopObservingGlucoseData", "Error removing observers: ${e.message}")
+                    Log.e("stopObservingGlucoseData", "Error removing observers: ${e.message}", e)
+                    captureModuleException("stopObservingGlucoseData.removeObservers", e)
                 }
             }
 
@@ -1158,7 +1329,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             lastDeviceStatus = null
 
         } catch (e: Exception) {
-            Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}")
+            Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}", e)
+            captureModuleException("stopObservingGlucoseData", e)
         }
     }
 
@@ -1185,7 +1357,14 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
                 )
             } catch (e: Exception) {
-                Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}")
+                Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}", e)
+                captureModuleException(
+                    "uploadBatchSynchronously",
+                    RuntimeException(
+                        "uploadBatchSynchronously failed | batchIndex=$batchIndex",
+                        e
+                    )
+                )
                 continuation.resume(false)
             }
         }
@@ -1212,7 +1391,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                             "Sync metadata updated: glucoseId=${it.glucoseId}, time=${it.timeInMillis}"
                         )
                     } catch (e: Exception) {
-                        Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}")
+                        Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}", e)
+                        captureModuleException("updateSyncMetadata", e)
                     }
                 }
             }
@@ -1295,8 +1475,14 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             mReactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 ?.emit(eventName, map)
         } catch (e: Exception) {
-            Log.e("Error sendDataToReact: ", e.message.toString())
-            e.printStackTrace()
+            Log.e("Error sendDataToReact: ", e.message.toString(), e)
+            captureModuleException(
+                "sendDataToReact",
+                RuntimeException(
+                    "sendDataToReact failed | eventName=$eventName;status=$status",
+                    e
+                )
+            )
         }
     }
 

package/android/src/main/res/layout/activity_search_transmitter.xml

@@ -624,7 +624,17 @@
                     app:layout_constraintEnd_toEndOf="parent"
                     app:layout_constraintStart_toStartOf="parent"
                     app:layout_constraintTop_toTopOf="parent"
-                    app:srcCompat="@drawable/ic_transmitter" />
+                    app:srcCompat="@drawable/ic_transmitter"
+                    android:visibility="gone" />
+
+                <androidx.appcompat.widget.AppCompatImageView
+                    android:id="@+id/ivPodDetectError"
+                    android:layout_width="100dp"
+                    android:layout_height="100dp"
+                    app:layout_constraintEnd_toEndOf="parent"
+                    app:layout_constraintStart_toStartOf="parent"
+                    app:layout_constraintTop_toTopOf="parent"
+                    app:srcCompat="@drawable/img_cgm_pod_detect_error" />
 
                 <TextView
                     android:layout_width="wrap_content"
@@ -641,7 +651,7 @@
                     app:layout_constraintBottom_toBottomOf="parent"
                     app:layout_constraintEnd_toEndOf="parent"
                     app:layout_constraintStart_toStartOf="parent"
-                    app:layout_constraintTop_toBottomOf="@id/ivTrans" />
+                    app:layout_constraintTop_toBottomOf="@id/ivPodDetectError" />
 
             </androidx.constraintlayout.widget.ConstraintLayout>
 

package/package.json

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