react-native-mytatva-rn-sdk 1.2.79 → 1.2.80

package/android/build.gradle

@@ -131,7 +131,6 @@ dependencies {
     implementation 'com.google.android.material:material:1.8.0'
     implementation 'androidx.activity:activity:1.9.3'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
-    implementation "io.sentry:sentry-android:7.11.0"
     implementation 'com.github.bumptech.glide:glide:4.15.1'
     implementation 'com.github.bumptech.glide:okhttp3-integration:4.15.1'
     implementation 'androidx.multidex:multidex:2.0.1'

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

@@ -29,13 +29,6 @@ import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
-import io.sentry.IScope
-import io.sentry.IHub
-import io.sentry.android.core.SentryAndroid
-import io.sentry.android.core.SentryAndroidOptions
-import io.sentry.Hub
-import io.sentry.SentryLevel
-import io.sentry.SentryEvent
 import com.mytatvarnsdk.activity.HelpActivity
 import com.mytatvarnsdk.activity.StartCGMActivity
 import com.mytatvarnsdk.model.AllCGMLogRequest
@@ -101,156 +94,12 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             ViewModelProvider.AndroidViewModelFactory.getInstance(reactContext.applicationContext as Application)
         mModel = ViewModelProvider(viewModelStore, factory)[MainActivityModel::class.java]
         authenticateSDKService = AuthenticateSDKService(scope = scope)
-
-        initSentryIfNeeded(reactContext)
-    }
-
-    private fun initSentryIfNeeded(context: ReactApplicationContext) {
-        // Create a separate Sentry Hub with SDK's own DSN
-        // This ensures we don't interfere with RN app's Sentry instance
-        // We create our own Hub WITHOUT calling SentryAndroid.init() to avoid overriding global Sentry
-        if (sentryInitialized.compareAndSet(false, true)) {
-            try {
-                Log.d("Sentry", "Initializing SDK Sentry with separate Hub and DSN (not affecting global Sentry)")
-                
-                // Create SentryOptions with SDK's DSN
-                // Use SentryAndroidOptions for Android-specific configuration
-                val options = SentryAndroidOptions().apply {
-                    dsn = "https://8c1585c04b41a8bdf3271d89c7361530@o4509755819294720.ingest.us.sentry.io/4510520864735232"
-                    isDebug = true // remove or toggle for production
-                    tracesSampleRate = 1.0
-                    environment = env.ifEmpty { "development" }
-                    // Configure Android-specific options
-                    setAttachScreenshot(false)
-                    setAttachViewHierarchy(false)
-                }
-                
-                // Set Android context - this is needed for Android integrations
-                // But we DON'T call SentryAndroid.init() to avoid overriding global Sentry
-                val androidContext = context.applicationContext
-                
-                // Manually configure Android-specific settings if needed
-                // Note: Some Android integrations might not work without init(), but core functionality will
-                
-                // Create a separate Hub for SDK use (doesn't affect global Sentry)
-                sdkSentryHub = Hub(options)
-                
-                // Capture initial message after a brief delay to ensure Sentry is ready
-                Handler(Looper.getMainLooper()).postDelayed({
-                    try {
-                        val sentryMessage = io.sentry.protocol.Message().apply {
-                            formatted = "Goodflip SDK started"
-                        }
-                        val event = SentryEvent().apply {
-                            setMessage(sentryMessage)
-                            level = SentryLevel.INFO
-                        }
-                        sdkSentryHub?.captureEvent(event)
-                        Log.d("Sentry", "Goodflip SDK started message sent to SDK Sentry")
-                    } catch (e: Exception) {
-                        Log.e("Sentry", "Error sending initial message: ${e.message}", e)
-                    }
-                }, 200)
-            } catch (e: Exception) {
-                Log.e("Sentry", "Error initializing SDK Sentry: ${e.message}", e)
-                sentryInitialized.set(false) // Reset on error so we can try again
-            }
-        }
-    }
-
-    private fun captureSentryMessage(message: String, extras: Map<String, String> = emptyMap()) {
-        try {
-            // Always try to use Sentry - it might be initialized by RN app even if our flag is false
-            // Ensure we're on main thread for Sentry operations
-            if (Looper.myLooper() == Looper.getMainLooper()) {
-                captureSentryMessageInternal(message, extras)
-            } else {
-                Handler(Looper.getMainLooper()).post {
-                    captureSentryMessageInternal(message, extras)
-                }
-            }
-        } catch (e: Exception) {
-            Log.e("Sentry", "Error capturing Sentry message: ${e.message}", e)
-        }
-    }
-
-    private fun captureSentryMessageInternal(message: String, extras: Map<String, String> = emptyMap()) {
-        try {
-            val hub = sdkSentryHub
-            if (hub == null) {
-                Log.w("Sentry", "SDK Sentry Hub not initialized, skipping message: $message")
-                return
-            }
-            
-            hub.withScope { scope ->
-                addContact(scope)
-                extras.forEach { (key, value) ->
-                    scope.setExtra(key, value)
-                }
-                val msgText = message
-                val sentryMessage = io.sentry.protocol.Message().apply {
-                    formatted = msgText
-                }
-                val event = SentryEvent().apply {
-                    setMessage(sentryMessage)
-                    level = SentryLevel.INFO
-                }
-                hub.captureEvent(event)
-                Log.d("Sentry", "Message captured to SDK Sentry: $msgText")
-            }
-        } catch (e: Exception) {
-            Log.e("Sentry", "Error in captureSentryMessageInternal: ${e.message}", e)
-        }
-    }
-
-    private fun captureSentryException(exception: Throwable, extras: Map<String, String> = emptyMap()) {
-        try {
-            // Always try to use Sentry - it might be initialized by RN app even if our flag is false
-            // Ensure we're on main thread for Sentry operations
-            if (Looper.myLooper() == Looper.getMainLooper()) {
-                captureSentryExceptionInternal(exception, extras)
-            } else {
-                Handler(Looper.getMainLooper()).post {
-                    captureSentryExceptionInternal(exception, extras)
-                }
-            }
-        } catch (e: Exception) {
-            Log.e("Sentry", "Error capturing Sentry exception: ${e.message}", e)
-        }
-    }
-
-    private fun captureSentryExceptionInternal(exception: Throwable, extras: Map<String, String> = emptyMap()) {
-        try {
-            val hub = sdkSentryHub
-            if (hub == null) {
-                Log.w("Sentry", "SDK Sentry Hub not initialized, skipping exception: ${exception.message}")
-                return
-            }
-            
-            hub.withScope { scope ->
-                addContact(scope)
-                extras.forEach { (key, value) ->
-                    scope.setExtra(key, value)
-                }
-                val event = SentryEvent().apply {
-                    throwable = exception
-                    level = SentryLevel.ERROR
-                }
-                hub.captureEvent(event)
-                Log.d("Sentry", "Exception captured to SDK Sentry: ${exception.message}")
-            }
-        } catch (e: Exception) {
-            Log.e("Sentry", "Error in captureSentryExceptionInternal: ${e.message}", e)
-        }
     }
 
-
     companion object {
         var mReactContext: ReactApplicationContext? = null
         var userToken: String = ""
         var env: String = ""
-        private val sentryInitialized = AtomicBoolean(false)
-        private var sdkSentryHub: IHub? = null
     }
 
     override fun getName(): String {
@@ -261,11 +110,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         currentUserData = data
     }
 
-    private fun addContact(scope: IScope) {
-        val contact = currentUserData?.getString("contact_no") ?: "unknown"
-        scope.setExtra("contact_no", contact)
-    }
-
     @ReactMethod
     fun observeDeviceStatus(token: String, envType: String) {
         try {
@@ -710,15 +554,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         try {
             // Additional safety check
             if (pocGlucose.glucoseId == null) {
-                val timeInMillis = pocGlucose.timeInMillis?.let { it.toString() } ?: "null"
-                captureSentryMessage(
-                    "handleGlucoseData: glucoseId null, skipping",
-                    mapOf(
-                        "envType" to envType,
-                        "glucoseId" to "null",
-                        "timeInMillis" to timeInMillis
-                    )
-                )
                 Log.w("handleGlucoseData", "Glucose ID is null, skipping processing")
                 return
             }
@@ -737,16 +572,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 val json = gson.toJson(request)
 
                 Log.d("Glucose data 3 min==> ", "Glucose data 3 min==> final Json: $json")
-                val glucoseId = pocGlucose.glucoseId?.let { it.toString() } ?: "null"
-                val timeInMillis = pocGlucose.timeInMillis?.let { it.toString() } ?: "null"
-                captureSentryMessage(
-                    "handleGlucoseData: single upload start",
-                    mapOf(
-                        "glucoseId" to glucoseId,
-                        "timeInMillis" to timeInMillis,
-                        "envType" to envType
-                    )
-                )
 
                 authenticateSDKService.postCGMData(
                     environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
@@ -754,27 +579,11 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     token = userToken,
                     responseListener = object : AuthenticateSDKService.ResponseListener {
                         override fun onResponseSuccess(response: String) {
-                            val glucoseId = pocGlucose.glucoseId?.let { it.toString() } ?: "null"
-                            captureSentryMessage(
-                                "handleGlucoseData: single upload success",
-                                mapOf(
-                                    "glucoseId" to glucoseId,
-                                    "envType" to envType
-                                )
-                            )
                             updateSyncMetadata(pocGlucose)
                             Log.d("CGM Data", "Single glucose data uploaded successfully")
                         }
 
                         override fun onResponseFail() {
-                            val glucoseId = pocGlucose.glucoseId?.let { it.toString() } ?: "null"
-                            captureSentryMessage(
-                                "handleGlucoseData: single upload fail",
-                                mapOf(
-                                    "glucoseId" to glucoseId,
-                                    "envType" to envType
-                                )
-                            )
                             Log.e("CGM Data", "Failed to upload single glucose data")
                         }
                     }
@@ -787,26 +596,10 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                      )
                  } */
             } else {
-                val glucoseId = pocGlucose.glucoseId?.let { it.toString() } ?: "null"
-                captureSentryMessage(
-                    "handleGlucoseData: glucose error ${pocGlucose.errorCode}",
-                    mapOf(
-                        "envType" to envType,
-                        "glucoseId" to glucoseId
-                    )
-                )
                 Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
                 handleGlucoseError(pocGlucose, envType)
             }
         } catch (e: Exception) {
-            val glucoseId = pocGlucose.glucoseId?.let { it.toString() } ?: "null"
-            captureSentryException(
-                e,
-                mapOf(
-                    "glucoseId" to glucoseId,
-                    "envType" to envType
-                )
-            )
             Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}")
             e.printStackTrace()
         }
@@ -867,9 +660,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     ) {
         Log.d("function call", "observeAllGlucoseData")
 
-        // Ensure Sentry is initialized
-        mReactContext?.let { initSentryIfNeeded(it) }
-
         // Use atomic compareAndSet to prevent concurrent batch processing
         if (!isBatchProcessing.compareAndSet(false, true)) {
             Log.d("observeAllGlucoseData", "Batch processing already in progress, skipping duplicate call")
@@ -895,40 +685,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 val lastSyncData = prefsHelper?.lastSyncData
 
                 val lastSyncDataJson = Gson().toJson(lastSyncData).toString()
-                captureSentryMessage(
-                    "observeAllGlucoseData method =====",
-                    mapOf("lastSyncData" to lastSyncDataJson)
-                )
                 Log.d("lastSyncData: ", lastSyncDataJson)
 
                 val currentTime = System.currentTimeMillis()
                 val dataAge = if (lastSyncData != null) currentTime - lastSyncData.timeInMillis else 0L
 
-                captureSentryMessage(
-                    "observeAllGlucoseData method",
-                    mapOf(
-                        "currentTime" to currentTime.toString(),
-                        "dataAge" to dataAge.toString(),
-                        "lastSyncData" to Gson().toJson(lastSyncData).toString()
-                    )
-                )
-
                 if (lastSyncData != null && dataAge > 3 * 60 * 1000L) {
                     val glucoseData = mModel.getGlucoseBetweenTime(lastSyncData.timeInMillis)
 
                     val glucoseCount = glucoseData?.size ?: 0
-                    val lastEntry = glucoseData?.lastOrNull()
-                    val lastEntryGlucoseId = lastEntry?.glucoseId?.let { it.toString() } ?: "null"
-                    val lastEntryTimeInMillis = lastEntry?.timeInMillis?.let { it.toString() } ?: "null"
-                    captureSentryMessage(
-                        "observeAllGlucoseData batch fetch",
-                        mapOf(
-                            "glucoseCount" to glucoseCount.toString(),
-                            "lastEntry_glucoseId" to lastEntryGlucoseId,
-                            "lastEntry_timeInMillis" to lastEntryTimeInMillis
-                        )
-                    )
-
                     Log.d("observeAllGlucoseData", "Retrieved ${glucoseCount} records from DB")
 
                     // Combine database data with pending queue data
@@ -957,30 +722,12 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
 
                     if (sortedGlucoseData.isNotEmpty()) {
-                        captureSentryMessage(
-                            "observeAllGlucoseData: got data",
-                            mapOf(
-                                "sortedCount" to sortedGlucoseData.size.toString(),
-                                "oldestTime" to sortedGlucoseData.first().timeInMillis.toString(),
-                                "newestTime" to sortedGlucoseData.last().timeInMillis.toString()
-                            )
-                        )
-
                         processBatchDataAndStartObserver(
                             sortedGlucoseData,
                             isForClear,
                             envType
                         )
                     } else {
-                        val lastSyncTime = lastSyncData?.timeInMillis?.let { it.toString() } ?: "null"
-                        captureSentryMessage(
-                            "observeAllGlucoseData: No historical data found, starting live observation",
-                            mapOf(
-                                "pendingCount" to pendingData.size.toString(),
-                                "lastSyncTime" to lastSyncTime
-                            )
-                        )
-
                         Log.d(
                             "observeAllGlucoseData",
                             "No historical data found, starting live observation"
@@ -994,18 +741,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 } else {
                     // No batch needed, but process pending data if any
                     if (pendingData.isNotEmpty()) {
-                            val lastPending = pendingData.lastOrNull()
-                        val lastPendingGlucoseId = lastPending?.glucoseId?.let { it.toString() } ?: "null"
-                        val lastPendingTime = lastPending?.timeInMillis?.let { it.toString() } ?: "null"
-                        captureSentryMessage(
-                            "observeAllGlucoseData: no btach process,  processing pending items",
-                            mapOf(
-                                "pendingCount" to pendingData.size.toString(),
-                                "lastPendingGlucoseId" to lastPendingGlucoseId,
-                                "lastPendingTime" to lastPendingTime
-                            )
-                        )
-
                         Log.d("observeAllGlucoseData", "Processing ${pendingData.size} pending items")
                         pendingData.forEach { data ->
                             val glucoseId = data.glucoseId
@@ -1022,10 +757,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     }
                 }
             } catch (e: Exception) {
-                captureSentryException(
-                    e,
-                    mapOf("errorMessage" to "observeAllGlucoseData, Error in batch processing: ${e.message}")
-                )
                 Log.e("observeAllGlucoseData", "Error in batch processing: ${e.message}", e)
             } finally {
                 // Always reset the flag
@@ -1051,16 +782,8 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
             if (success) {
                 Log.d("processBatchDataAndStartObserver", "Batch processing completed successfully")
-                captureSentryMessage(
-                    "processBatchDataAndStartObserver: batch success",
-                    mapOf("dataListSize" to dataList.size.toString())
-                )
             } else {
                 Log.w("processBatchDataAndStartObserver", "Batch processing had failures")
-                captureSentryMessage(
-                    "processBatchDataAndStartObserver: batch failures",
-                    mapOf("dataListSize" to dataList.size.toString())
-                )
             }
 
             // Don't reset flag here - it's reset in observeAllGlucoseData's finally block
@@ -1082,10 +805,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
 
         } catch (e: Exception) {
-            captureSentryException(
-                e,
-                mapOf("dataListSize" to dataList.size.toString())
-            )
             Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}")
             // Start live observation even on error
             withContext(Dispatchers.Main) {
@@ -1305,23 +1024,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 if (uploadSuccessful) {
                     lastSyncedRecord = batch.lastOrNull()
                     // Update sync metadata after each successful batch
-                    captureSentryMessage(
-                        "Batch Upload: ✅ Batch $index uploaded and synced successfully",
-                        mapOf(
-                            "envType" to env,
-                            "lastSyncedRecord" to Gson().toJson(lastSyncedRecord ?: "null")
-                        )
-                    )
                     updateSyncMetadata(lastSyncedRecord)
                     Log.d("Batch Upload", "✅ Batch $index uploaded and synced successfully")
                 } else {
-                    captureSentryMessage(
-                        "Batch Upload: ❌ Batch $index failed",
-                        mapOf(
-                            "envType" to env,
-                            "lastSyncedRecord" to Gson().toJson(lastSyncedRecord ?: "null")
-                        )
-                    )
                     allBatchesSuccessful = false
                     Log.e("Batch Upload", "❌ Batch $index failed")
                     // Continue with next batch instead of breaking (optional based on your needs)
@@ -1332,15 +1037,6 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 delay(500L)
 
             } catch (e: Exception) {
-                captureSentryException(
-                    e,
-                    mapOf(
-                        "batchIndex" to index.toString(),
-                        "batchSize" to batch.size.toString(),
-                        "envType" to env,
-                        "lastSyncedRecord" to Gson().toJson(lastSyncedRecord ?: "null")
-                    )
-                )
                 Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}")
                 allBatchesSuccessful = false
                 // Continue processing other batches
@@ -1414,36 +1110,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     token = userToken,
                     responseListener = object : AuthenticateSDKService.ResponseListener {
                         override fun onResponseSuccess(response: String) {
-                            captureSentryMessage(
-                                "uploadBatchSynchronously: success",
-                                mapOf(
-                                    "batchIndex" to batchIndex.toString(),
-                                    "envType" to envType
-                                )
-                            )
                             continuation.resume(true)
                         }
 
                         override fun onResponseFail() {
-                            captureSentryMessage(
-                                "uploadBatchSynchronously: fail",
-                                mapOf(
-                                    "batchIndex" to batchIndex.toString(),
-                                    "envType" to envType
-                                )
-                            )
                             continuation.resume(false)
                         }
                     }
                 )
             } catch (e: Exception) {
-                captureSentryException(
-                    e,
-                    mapOf(
-                        "batchIndex" to batchIndex.toString(),
-                        "envType" to envType
-                    )
-                )
                 Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}")
                 continuation.resume(false)
             }

package/package.json

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