react-native-mytatva-rn-sdk 1.2.92 → 1.2.94

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

@@ -1,4 +1,4 @@
-package com.mytatvarnsdk
+​package com.mytatvarnsdk
 
 import android.app.Application
 import android.bluetooth.BluetoothAdapter
@@ -12,6 +12,9 @@ import androidx.lifecycle.Observer
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.ViewModelStore
 import cgmblelib.Enum.enumError
+import cgmblelib.Enum.enumGlucoseStatus
+import cgmblelib.Enum.enumSound
+import cgmblelib.Enum.enumTrend
 import cgmblelib.base.BApplication
 import cgmblelib.database.entity.PocDevice
 import cgmblelib.database.entity.PocGlucose
@@ -33,19 +36,23 @@ import com.mytatvarnsdk.activity.HelpActivity
 import com.mytatvarnsdk.activity.StartCGMActivity
 import com.mytatvarnsdk.model.AllCGMLogRequest
 import com.mytatvarnsdk.model.CgmLog
+import com.mytatvarnsdk.model.ErrorObject
+import com.mytatvarnsdk.model.GlucoseStatusObject
+import com.mytatvarnsdk.model.TrendObject
 import com.mytatvarnsdk.model.CgmSensorResponse
 import com.mytatvarnsdk.model.GlucoseLog
-import com.mytatvarnsdk.model.GlucoseLog.ErrorObject
-import com.mytatvarnsdk.model.GlucoseLog.GlucoseStatusObject
-import com.mytatvarnsdk.model.GlucoseLog.TrendObject
 import com.mytatvarnsdk.model.GlucoseLogRequest
 import com.mytatvarnsdk.model.MainActivityModel
 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.ScopeCallback
 import io.sentry.Sentry
+import io.sentry.SentryAttributes
 import io.sentry.SentryLevel
+import io.sentry.SentryLogLevel
+import io.sentry.logger.SentryLogParameters
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -116,79 +123,186 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         return "CgmTrackyLib"
     }
 
+    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) {
+            ""
+        }
+
     /**
+     * Structured Sentry log (like RN `Sentry.logger.info/warn/error`).
      * 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.
+     *
+     * Sentry 8.x: `Sentry.logger()` sends to **Explore → Logs** and requires native
+     * `enableLogs: true` (mapped from parent `@sentry/react-native` init). It is NOT a
+     * drop-in replacement for `captureException` / `captureMessage` (Issues tab).
+     *
+     * When logs are disabled or unavailable, falls back to captureMessage/captureException
+     * so operational telemetry still reaches Sentry Issues (same as Sentry 6.x behaviour).
      */
-    private fun captureModuleException(
+    private fun logModuleEvent(
         where: String,
-        data: Any?,
-        level: SentryLevel = SentryLevel.ERROR
+        message: String = "",
+        level: SentryLogLevel = SentryLogLevel.INFO,
+        jsonPayload: String? = null,
+        throwable: Throwable? = null,
+        attributes: Map<String, String> = emptyMap()
     ) {
         try {
-            Sentry.withScope { scope ->
-                scope.setTag("cgm_tracky_lib", "true")
-                scope.setExtra("location", where)
-                if (env.isNotEmpty()) {
-                    scope.setExtra("tatva_env", env)
+            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 ?: ""
+            }
 
-                when (data) {
-                    null ->
-                        run {
-                            Sentry.captureMessage("CgmTrackyLib: $where", level)
-                        }
+            val clippedJson = jsonPayload?.let { clipForSentry(it) }
+            val logMessage = clipForSentry(
+                "CgmTrackyLib: $where | $resolvedMessage",
+                MAX_SENTRY_MESSAGE_DATA_CHARS
+            )
 
-                    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)
-                        }
+            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) ->
+                sentryAttributes[key] = clipForSentry(value, 500)
+            }
 
-                    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
-                            }
+            val logsEnabled = try {
+                Sentry.getCurrentScopes()?.options?.logs?.isEnabled == true
+            } catch (_: Throwable) {
+                false
+            }
 
-                        Sentry.captureMessage("CgmTrackyLib: $where | data=$messageData", level)
-                    }
+            if (logsEnabled) {
+                val logParams = SentryLogParameters.create(
+                    SentryAttributes.fromMap(sentryAttributes)
+                )
+                logParams.origin = "cgm-tracky-lib"
+                Sentry.logger().log(level, logParams, logMessage)
+                // Exceptions logged via logger should also appear under Issues (pre-8.x behaviour).
+                if (throwable != null && level >= SentryLogLevel.ERROR) {
+                    captureModuleException(where, throwable, sentryAttributes)
                 }
+            } else {
+                captureModuleEventFallback(where, logMessage, level, throwable, sentryAttributes)
+            }
+        } catch (sentryEx: Throwable) {
+            try {
+                Log.w(
+                    "logModuleEvent",
+                    "Sentry logger failed for [$where]: ${sentryEx.message}",
+                    sentryEx
+                )
+                Log.e("CgmTrackyLib", "[$where]", throwable ?: sentryEx)
+            } catch (_: Throwable) {
+                // Last resort: never propagate to callers.
+            }
+        }
+    }
+
+    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)
+        if (env.isNotEmpty()) {
+            scope.setTag("tatva_env", env)
+        }
+        attributes.forEach { (key, value) ->
+            scope.setExtra(key, value.toString())
+        }
+    }
+
+    /** Fallback when native logs are disabled — sends to Issues via captureMessage. */
+    private fun captureModuleEventFallback(
+        where: String,
+        message: String,
+        level: SentryLogLevel,
+        throwable: Throwable?,
+        attributes: Map<String, Any>
+    ) {
+        val scopeCallback = applyModuleScopeExtras(where, attributes)
+        if (throwable != null) {
+            Sentry.captureException(throwable, scopeCallback)
+        } else {
+            Sentry.captureMessage(message, mapLogLevelToEventLevel(level), scopeCallback)
+        }
+    }
+
+    private fun captureModuleException(
+        where: String,
+        throwable: Throwable,
+        attributes: Map<String, Any>
+    ) {
+        Sentry.captureException(throwable, applyModuleScopeExtras(where, attributes))
+    }
+
+    /** Wraps log preparation + emission so a bad payload/toString() cannot break CGM flows. */
+    private inline fun safeLogModuleEvent(block: () -> Unit) {
+        try {
+            block()
+        } catch (t: Throwable) {
+            try {
+                Log.w("logModuleEvent", "Failed to prepare Sentry log: ${t.message}", t)
+            } catch (_: Throwable) {
+                // Never propagate to callers.
             }
-        } catch (sentryEx: Exception) {
-            // If Sentry itself fails, never crash the CGM processing flow.
-            Log.e("captureModuleException", "Sentry capture failed: ${sentryEx.message}", sentryEx)
         }
     }
 
+    private fun cgmStatusDeviceAttributes(
+        status: String,
+        device: PocDevice?,
+        sensorId: String?,
+        bleEnabled: Boolean,
+        extra: Map<String, String> = emptyMap(),
+    ): Map<String, String> {
+        val attrs = mutableMapOf(
+            "cgm_status" to status,
+            "sensor_id" to (sensorId ?: ""),
+            "ble_enabled" to bleEnabled.toString(),
+            "is_bound_and_connect" to (device?.isBoundAndConnect?.toString() ?: "unknown"),
+            "is_unbind" to (device?.isUnBind?.toString() ?: "unknown"),
+            "is_bound_but_disconnect" to (device?.isBoundButDisConnect?.toString() ?: "unknown"),
+            "transmitter_name" to (device?.name.orEmpty()),
+        )
+        attrs.putAll(extra)
+        return attrs
+    }
+
     private fun updateUserData(data: ReadableMap?) {
         currentUserData = data
         // Always reset so stale values from a previous user don't persist
@@ -203,7 +317,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
         } catch (e: Exception) {
             Log.e("updateUserData", "Error extracting last_connect_cgm: ${e.message}", e)
-            captureModuleException("updateUserData", e)
+            safeLogModuleEvent {
+                logModuleEvent("updateUserData", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -237,7 +353,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
         } catch (e: Exception) {
             Log.e("observeDeviceStatus", "observeDeviceStatus: ${e.message}", e)
-            captureModuleException("observeDeviceStatus", e)
+            safeLogModuleEvent {
+                logModuleEvent("observeDeviceStatus", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -365,7 +483,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
         } catch (e: Exception) {
             Log.e("observeTransmitterUnbindStatus", "observeTransmitterUnbindStatus: ${e.message}", e)
-            captureModuleException("observeTransmitterUnbindStatus", e)
+            safeLogModuleEvent {
+                logModuleEvent("observeTransmitterUnbindStatus", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -396,11 +516,29 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
                 Log.d("Device event Status", "Device event Status: $status")
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "postEventDataToAPI.cgmStatusResolved",
+                        message = "CGM status resolved: $status | bleEnabled=$bleStatus",
+                        level = SentryLogLevel.INFO,
+                        attributes = cgmStatusDeviceAttributes(status, device, sensorId, bleStatus),
+                    )
+                }
+
                 if (status == DeviceStatus.DISCONNECTED.id && !isDebounceTimerActive) {
                     // Start debounce timer for 1 minutes
                     debounceDeviceTimer = Timer()
                     isDebounceTimerActive = true
 
+                    safeLogModuleEvent {
+                        logModuleEvent(
+                            where = "postEventDataToAPI.cgmStatusDebounceScheduled",
+                            message = "CGM DISCONNECTED debounce started (1 min) | status=$status",
+                            level = SentryLogLevel.INFO,
+                            attributes = cgmStatusDeviceAttributes(status, device, sensorId, bleStatus),
+                        )
+                    }
+
                     debounceDeviceTimer?.schedule(object : TimerTask() {
                         override fun run() {
                             isDebounceTimerActive = false
@@ -422,7 +560,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
             } catch (e: Exception) {
                 Log.e("postEventDataToAPI", "postEventDataToAPI: ${e.message}", e)
-                captureModuleException("postEventDataToAPI", e)
+                safeLogModuleEvent {
+                    logModuleEvent("postEventDataToAPI", throwable = e, level = SentryLogLevel.ERROR)
+                }
             }
         }
     }
@@ -438,6 +578,7 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
         Log.d("Device event Status", "Last Device event lastDeviceStatus API: $lastDeviceStatus")
 
         if (status.isNotEmpty() && status != lastDeviceStatus) {
+            val previousStatus = lastDeviceStatus
             lastDeviceStatus = status
 
             Log.d("Device event Status", "Device event Status API: $status")
@@ -455,6 +596,25 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 put("rawData", rawData)
             }
             Log.d("commingg", "Yuppp")
+
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "callEventAPI.cgmStatusChanged",
+                    message = "CGM status changed | previous=${previousStatus ?: "none"} | new=$status",
+                    level = SentryLogLevel.INFO,
+                    jsonPayload = obj.toString(),
+                    attributes = cgmStatusDeviceAttributes(
+                        status = status,
+                        device = device,
+                        sensorId = sensorId,
+                        bleEnabled = BluetoothAdapter.getDefaultAdapter()?.isEnabled == true,
+                        extra = mapOf(
+                            "previous_cgm_status" to (previousStatus ?: ""),
+                        ),
+                    ),
+                )
+            }
+
             authenticateSDKService.postDeviceData(
                 environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                 data = obj.toString(),
@@ -489,7 +649,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             currentActivity?.startActivity(intent)
         } catch (e: Exception) {
             Log.e("startCgmTracky", "startCgmTracky: ${e.message}", e)
-            captureModuleException("startCgmTracky", e)
+            safeLogModuleEvent {
+                logModuleEvent("startCgmTracky", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -518,7 +680,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             )
         } catch (e: Exception) {
             Log.e("reconnectCgmTracky", "reconnectCgmTracky: ${e.message}", e)
-            captureModuleException("reconnectCgmTracky", e)
+            safeLogModuleEvent {
+                logModuleEvent("reconnectCgmTracky", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -529,7 +693,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             currentActivity?.startActivity(intent)
         } catch (e: Exception) {
             Log.e("openHelpSupport", "openHelpSupport: ${e.message}", e)
-            captureModuleException("openHelpSupport", e)
+            safeLogModuleEvent {
+                logModuleEvent("openHelpSupport", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -601,7 +767,13 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         Log.d("observeGlucoseData", "Live glucose observer started successfully")
                     } catch (e: Exception) {
                         Log.e("observeGlucoseData", "Error adding observer: ${e.message}", e)
-                        captureModuleException("observeGlucoseData.observeForever", e)
+                        safeLogModuleEvent {
+                            logModuleEvent(
+                                "observeGlucoseData.observeForever",
+                                throwable = e,
+                                level = SentryLogLevel.ERROR
+                            )
+                        }
                         glucoseObserver = null
                         isObserving = false
                     }
@@ -610,7 +782,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         } catch (e: Exception) {
             Log.e("observeGlucoseData", "observeGlucoseData: ${e.message}", e)
-            captureModuleException("observeGlucoseData", e)
+            safeLogModuleEvent {
+                logModuleEvent("observeGlucoseData", throwable = e, level = SentryLogLevel.ERROR)
+            }
             isObserving = false
             glucoseObserver = null
         }
@@ -694,8 +868,18 @@ 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)
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "handleGlucoseData.postCGMData",
+                        message = "Posting single glucose data | glucoseId=${pocGlucose.glucoseId ?: ""}",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = json,
+                        attributes = mapOf(
+                            "glucoseId" to (pocGlucose.glucoseId?.toString() ?: "")
+                        )
+                    )
+                }
+
                 authenticateSDKService.postCGMData(
                     environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                     data = json,
@@ -703,31 +887,36 @@ 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
-                            // )
+                            safeLogModuleEvent {
+                                logModuleEvent(
+                                    where = "handleGlucoseData.postCGMData.success",
+                                    message = "Single glucose data uploaded successfully | glucoseId=${pocGlucose.glucoseId ?: ""}",
+                                    level = SentryLogLevel.INFO,
+                                    jsonPayload = json,
+                                    attributes = mapOf(
+                                        "glucoseId" to (pocGlucose.glucoseId?.toString() ?: ""),
+                                        "sdk_response" to response
+                                    )
+                                )
+                            }
                             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
-                            )
+                            safeLogModuleEvent {
+                                val lastSync = prefsHelper?.lastSyncData
+                                val contextData =
+                                    "failure_reason=Failed to upload single glucose data;" +
+                                            "pocGlucose=${pocGlucose};" +
+                                            "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                                            "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                                logModuleEvent(
+                                    where = "handleGlucoseData.postCGMData.fail",
+                                    message = contextData,
+                                    level = SentryLogLevel.WARN,
+                                    jsonPayload = json
+                                )
+                            }
                             Log.e("CGM Data", "Failed to upload single glucose data")
                         }
                     }
@@ -741,31 +930,37 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                  } */
             } else {
                 Log.d("handleGlucoseData", "Glucose data has error: ${pocGlucose.errorCode}")
+                safeLogModuleEvent {
+                    val lastSync = prefsHelper?.lastSyncData
+                    val contextData =
+                        "failure_reason=Glucose data has error: ${pocGlucose.errorCode};" +
+                                "pocGlucose=${pocGlucose};" +
+                                "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                                "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                    logModuleEvent(
+                        where = "handleGlucoseData==>postCGMData",
+                        message = "Glucose data has error: ${pocGlucose.errorCode} | $contextData",
+                        level = SentryLogLevel.INFO
+                    )
+                }
+                handleGlucoseError(pocGlucose, envType)
+            }
+        } catch (e: Exception) {
+            Log.e("handleGlucoseData", "Error handling glucose data: ${e.message}", e)
+            safeLogModuleEvent {
                 val lastSync = prefsHelper?.lastSyncData
                 val contextData =
-                    "failure_reason=Glucose data has error: ${pocGlucose.errorCode};" +
+                    "failure_reason=Exception in handleGlucoseData;" +
                             "pocGlucose=${pocGlucose};" +
                             "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
                             "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
-                captureModuleException(
-                    "handleGlucoseData==>postCGMData",
-                    "Glucose data has error: ${pocGlucose.errorCode} | $contextData",
-                    level = SentryLevel.INFO
+                logModuleEvent(
+                    where = "handleGlucoseData",
+                    message = "handleGlucoseData failed | $contextData",
+                    throwable = e,
+                    level = SentryLogLevel.ERROR
                 )
-                handleGlucoseError(pocGlucose, envType)
             }
-        } catch (e: Exception) {
-            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)
-            )
         }
     }
 
@@ -811,7 +1006,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             }
         } catch (e: Exception) {
             Log.e("handleGlucoseError", "Error handling glucose error: ${e.message}", e)
-            captureModuleException("handleGlucoseError", e)
+            safeLogModuleEvent {
+                logModuleEvent("handleGlucoseError", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -924,7 +1121,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 }
             } catch (e: Exception) {
                 Log.e("observeAllGlucoseData", "Error in batch processing: ${e.message}", e)
-                captureModuleException("observeAllGlucoseData", e)
+                safeLogModuleEvent {
+                    logModuleEvent("observeAllGlucoseData", throwable = e, level = SentryLogLevel.ERROR)
+                }
             } finally {
                 // Always reset the flag
                 isBatchProcessing.set(false)
@@ -973,7 +1172,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         } catch (e: Exception) {
             Log.e("processBatchDataAndStartObserver", "Error in batch processing: ${e.message}", e)
-            captureModuleException("processBatchDataAndStartObserver", e)
+            safeLogModuleEvent {
+                logModuleEvent("processBatchDataAndStartObserver", throwable = e, level = SentryLogLevel.ERROR)
+            }
             // Start live observation even on error
             withContext(Dispatchers.Main) {
                 if (!isObserving) {
@@ -993,7 +1194,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
             promise.resolve(dbFile.absolutePath)
         } catch (e: Exception) {
             Log.d("dbFileerrrr======", "dbFileerrrr======", e)
-            captureModuleException("getTrackLibDbPath", e)
+            safeLogModuleEvent {
+                logModuleEvent("getTrackLibDbPath", throwable = e, level = SentryLogLevel.ERROR)
+            }
             promise.reject("ERROR_DB_PATH", e)
         }
     }
@@ -1024,7 +1227,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         } catch (e: Exception) {
             Log.e("resetCgmState", "Error resetting CGM state: ${e.message}", e)
-            captureModuleException("resetCgmState", e)
+            safeLogModuleEvent {
+                logModuleEvent("resetCgmState", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -1085,11 +1290,54 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         } catch (e: Exception) {
             Log.e("getCgmLogFiles", "Error getting log files: ${e.message}", e)
-            captureModuleException("getCgmLogFiles", e)
+            safeLogModuleEvent {
+                logModuleEvent("getCgmLogFiles", throwable = e, level = SentryLogLevel.ERROR)
+            }
             promise.reject("ERROR_GET_LOG_FILES", e.message, e)
         }
     }
 
+    /** POC field: use SDK value when present, otherwise type-appropriate default. */
+    private fun mapPocGlucoseToCgmLog(pocGlucose: PocGlucose): CgmLog {
+        val trend = pocGlucose.trend ?: enumTrend.NONE
+        val glucoseStatus = pocGlucose.glucoseStatus ?: enumGlucoseStatus.NONE
+        val errorCode = pocGlucose.errorCode ?: enumError.NONE
+
+        return CgmLog(
+            timeInMillis = pocGlucose.timeInMillis,
+            countdownMinutes = pocGlucose.countdownMinutes,
+            countdownDays = pocGlucose.countdownDays,
+            hypoglycemiaEarlyWarnMinutes = pocGlucose.hypoglycemiaEarlyWarnMinutes,
+            showGlucoseMG = pocGlucose.showGlucoseMG,
+            glucoseId = pocGlucose.glucoseId ?: 0,
+            name = pocGlucose.name.orEmpty(),
+            bytes = pocGlucose.bytes ?: ByteArray(0),
+            showGlucose = pocGlucose.showGlucose,
+            Ib = pocGlucose.ib,
+            Iw = pocGlucose.iw,
+            countdownHours = pocGlucose.countdownHours,
+            T = pocGlucose.t,
+            year = pocGlucose.year,
+            month = pocGlucose.month,
+            day = pocGlucose.day,
+            hour = pocGlucose.hour,
+            minute = pocGlucose.minute,
+            trendObject = TrendObject(
+                trendId = trend.trendId,
+                drawableId = trend.drawableId,
+                widgetImg = trend.widgetImg,
+                apsChangeRate = trend.apsChangeRate.orEmpty()
+            ),
+            glucoseStatusObject = GlucoseStatusObject(
+                statusId = glucoseStatus.statusId
+            ),
+            errorObject = ErrorObject(
+                errorId = errorCode.errorId,
+                sound = errorCode.sound ?: enumSound.NONE
+            )
+        )
+    }
+
     // Updated batch processing method with better sync control
     private suspend fun processBatchDataSynchronously(
         dataList: List<PocGlucose>,
@@ -1141,42 +1389,25 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         for ((index, batch) in chunks.withIndex()) {
             try {
-                val transformedLogs = batch.map { pocGlucose ->
-                    CgmLog(
-                        timeInMillis = pocGlucose.timeInMillis,
-                        countdownMinutes = pocGlucose.countdownMinutes,
-                        countdownDays = pocGlucose.countdownDays,
-                        hypoglycemiaEarlyWarnMinutes = pocGlucose.hypoglycemiaEarlyWarnMinutes,
-                        showGlucoseMG = pocGlucose.showGlucoseMG,
-                        glucoseId = pocGlucose.glucoseId,
-                        name = pocGlucose.name,
-                        bytes = pocGlucose.bytes,
-                        showGlucose = pocGlucose.showGlucose,
-                        Ib = pocGlucose.ib,
-                        Iw = pocGlucose.iw,
-                        countdownHours = pocGlucose.countdownHours,
-                        T = pocGlucose.t,
-                        year = pocGlucose.year,
-                        month = pocGlucose.month,
-                        day = pocGlucose.day,
-                        hour = pocGlucose.hour,
-                        minute = pocGlucose.minute,
-                        trendObject = com.mytatvarnsdk.model.TrendObject(
-                            trendId = pocGlucose.trend.trendId,
-                            drawableId = pocGlucose.trend.drawableId,
-                            widgetImg = pocGlucose.trend.widgetImg,
-                            apsChangeRate = pocGlucose.trend.apsChangeRate
-                        ),
-                        glucoseStatusObject = com.mytatvarnsdk.model.GlucoseStatusObject(
-                            statusId = pocGlucose.glucoseStatus.statusId
-                        ),
-                        errorObject = com.mytatvarnsdk.model.ErrorObject(
-                            errorId = pocGlucose.errorCode.errorId,
-                            sound = pocGlucose.errorCode.sound
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "processBatchDataSynchronously.batchStarted",
+                        message = "Batch $index started | rawRecords=${batch.size} | totalBatches=${chunks.size}",
+                        level = SentryLogLevel.INFO,
+                        attributes = mapOf(
+                            "batchIndex" to index.toString(),
+                            "batch_raw_records" to batch.size.toString(),
+                            "total_batches" to chunks.size.toString(),
+                            "first_glucoseId" to (batch.firstOrNull()?.glucoseId?.toString() ?: ""),
+                            "last_glucoseId" to (batch.lastOrNull()?.glucoseId?.toString() ?: "")
                         )
                     )
                 }
 
+                val transformedLogs = batch.map { pocGlucose ->
+                    mapPocGlucoseToCgmLog(pocGlucose)
+                }
+
                 if (transformedLogs.isEmpty()) {
                     Log.d(
                         "processBatchDataSynchronously",
@@ -1195,14 +1426,45 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
                 val allResult = AllCGMLogRequest(vendor = "GoodFlip", logs = transformedLogs)
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "processBatchDataSynchronously.batchAssembled",
+                        message = "Batch $index assembled | records=${transformedLogs.size}",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = Gson().toJson(allResult),
+                        attributes = mapOf(
+                            "batchIndex" to index.toString(),
+                            "batch_records" to transformedLogs.size.toString(),
+                            "first_glucoseId" to (batch.firstOrNull()?.glucoseId?.toString() ?: ""),
+                            "last_glucoseId" to (batch.lastOrNull()?.glucoseId?.toString() ?: "")
+                        )
+                    )
+                }
+
                 // Attach sensorId at the top level of the batch payload sent to /cgm/logs
+                val activeSensorId =
+                    prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
                 val sensorPayloadJsonObject = JSONObject(Gson().toJson(allResult)).apply {
-                    val activeSensorId =
-                        prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
                     put("sensorId", activeSensorId)
                 }
                 val json = sensorPayloadJsonObject.toString()
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "processBatchDataSynchronously.batchPayloadBuilt",
+                        message = "Batch $index payload built | records=${transformedLogs.size} | activeSensorId=$activeSensorId",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = json,
+                        attributes = mapOf(
+                            "batchIndex" to index.toString(),
+                            "batch_records" to transformedLogs.size.toString(),
+                            "activeSensorId" to activeSensorId,
+                            "first_glucoseId" to (batch.firstOrNull()?.glucoseId?.toString() ?: ""),
+                            "last_glucoseId" to (batch.lastOrNull()?.glucoseId?.toString() ?: "")
+                        )
+                    )
+                }
+
                 // Check if logs array is empty - skip API call if so
                 if (transformedLogs.isEmpty()) {
                     Log.d(
@@ -1222,44 +1484,69 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 )
                 logLongJson("Batch $index JSON=>>> ", json)
 
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "processBatchDataSynchronously.postCGMData",
+                        message = "Posting batch $index | records=${transformedLogs.size}",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = json,
+                        attributes = mapOf(
+                            "batchIndex" to index.toString(),
+                            "batch_records" to transformedLogs.size.toString(),
+                            "first_glucoseId" to (batch.firstOrNull()?.glucoseId?.toString() ?: ""),
+                            "last_glucoseId" to (batch.lastOrNull()?.glucoseId?.toString() ?: "")
+                        )
+                    )
+                }
+
                 val uploadSuccessful = uploadBatchSynchronously(json, index, envType)
 
                 if (uploadSuccessful) {
                     lastSyncedRecord = batch.lastOrNull()
                     // Update sync metadata after each successful batch
                     updateSyncMetadata(lastSyncedRecord)
-                    // captureModuleException(
+                    // logModuleEvent(
                     //     "processBatchDataSynchronously.batchSuccess",
-                    //     json,
-                    //     extras =
-                    //         mapOf(
-                    //             "batchIndex" to index.toString(),
-                    //             "lastSyncedRecord" to (lastSyncedRecord?.toString() ?: "")
-                    //         ),
-                    //     level = SentryLevel.INFO
+                    //     jsonPayload = json,
+                    //     level = SentryLogLevel.INFO,
+                    //     attributes = mapOf("batchIndex" to index.toString())
                     // )
 
                     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
-                    )
+                    safeLogModuleEvent {
+                        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 ?: ""}"
+                        logModuleEvent(
+                            where = "processBatchDataSynchronously.batchUploadFailed",
+                            message = "postCGMData returned failure for batch $index | $contextData",
+                            level = SentryLogLevel.WARN,
+                            jsonPayload = json,
+                            attributes = mapOf(
+                                "batchIndex" to index.toString(),
+                                "batch_records" to batch.size.toString(),
+                                "payload_chars" to json.length.toString(),
+                                "first_glucoseId" to (batch.firstOrNull()?.glucoseId?.toString() ?: ""),
+                                "last_glucoseId" to (batch.lastOrNull()?.glucoseId?.toString() ?: ""),
+                                "first_timeInMillis" to (batch.firstOrNull()?.timeInMillis?.toString() ?: ""),
+                                "last_timeInMillis" to (batch.lastOrNull()?.timeInMillis?.toString() ?: ""),
+                                "lastSync_glucoseId" to (lastSync?.glucoseId?.toString() ?: ""),
+                                "lastSync_timeInMillis" to (lastSync?.timeInMillis?.toString() ?: "")
+                            )
+                        )
+                    }
                     // Continue with next batch instead of breaking (optional based on your needs)
                     // break
                 }
@@ -1269,13 +1556,15 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
             } catch (e: Exception) {
                 Log.e("Batch Upload", "❌ Batch $index exception: ${e.message}", e)
-                captureModuleException(
-                    "processBatchDataSynchronously.batch",
-                    RuntimeException(
-                        "processBatchDataSynchronously.batch failed | batchIndex=$index",
-                        e
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "processBatchDataSynchronously.batch",
+                        message = "processBatchDataSynchronously.batch failed | batchIndex=$index",
+                        throwable = e,
+                        level = SentryLogLevel.ERROR,
+                        attributes = mapOf("batchIndex" to index.toString())
                     )
-                )
+                }
                 allBatchesSuccessful = false
                 // Continue processing other batches
             }
@@ -1320,7 +1609,13 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                     Log.d("stopObservingGlucoseData", "Device observer removed successfully")
                 } catch (e: Exception) {
                     Log.e("stopObservingGlucoseData", "Error removing observers: ${e.message}", e)
-                    captureModuleException("stopObservingGlucoseData.removeObservers", e)
+                    safeLogModuleEvent {
+                        logModuleEvent(
+                            "stopObservingGlucoseData.removeObservers",
+                            throwable = e,
+                            level = SentryLogLevel.ERROR
+                        )
+                    }
                 }
             }
 
@@ -1330,7 +1625,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
 
         } catch (e: Exception) {
             Log.e("stopObservingGlucoseData", "Error stopping observer: ${e.message}", e)
-            captureModuleException("stopObservingGlucoseData", e)
+            safeLogModuleEvent {
+                logModuleEvent("stopObservingGlucoseData", throwable = e, level = SentryLogLevel.ERROR)
+            }
         }
     }
 
@@ -1342,29 +1639,89 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     ): Boolean {
         return suspendCoroutine { continuation ->
             try {
+                safeLogModuleEvent {
+                    val activeSensorId =
+                        prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
+                    logModuleEvent(
+                        where = "uploadBatchSynchronously.postCGMData",
+                        message = "Posting batch upload | batchIndex=$batchIndex | activeSensorId=$activeSensorId",
+                        level = SentryLogLevel.INFO,
+                        jsonPayload = json,
+                        attributes = mapOf(
+                            "batchIndex" to batchIndex.toString(),
+                            "activeSensorId" to activeSensorId,
+                            "payload_chars" to json.length.toString()
+                        )
+                    )
+                }
+
                 authenticateSDKService.postCGMData(
                     environment = if (envType.lowercase() == "uat") TATVA_ENVIRONMENT.STAGE else TATVA_ENVIRONMENT.PROD,
                     data = json,
                     token = userToken,
                     responseListener = object : AuthenticateSDKService.ResponseListener {
                         override fun onResponseSuccess(response: String) {
+                            safeLogModuleEvent {
+                                val activeSensorId =
+                                    prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
+                                logModuleEvent(
+                                    where = "uploadBatchSynchronously.postCGMData.success",
+                                    message = "Batch upload succeeded | batchIndex=$batchIndex | activeSensorId=$activeSensorId",
+                                    level = SentryLogLevel.INFO,
+                                    jsonPayload = json,
+                                    attributes = mapOf(
+                                        "batchIndex" to batchIndex.toString(),
+                                        "activeSensorId" to activeSensorId,
+                                        "payload_chars" to json.length.toString(),
+                                        "sdk_response" to response
+                                    )
+                                )
+                            }
                             continuation.resume(true)
                         }
 
                         override fun onResponseFail() {
+                            safeLogModuleEvent {
+                                val activeSensorId =
+                                    prefsHelper?.qrInformation?.sensor ?: lastConnectCgm ?: ""
+                                val lastSync = prefsHelper?.lastSyncData
+                                val contextData =
+                                    "failure_reason=postCGMData returned failure;" +
+                                            "batchIndex=$batchIndex;" +
+                                            "payload_chars=${json.length};" +
+                                            "activeSensorId=$activeSensorId;" +
+                                            "lastSync_glucoseId=${lastSync?.glucoseId ?: ""};" +
+                                            "lastSync_timeInMillis=${lastSync?.timeInMillis ?: ""}"
+                                logModuleEvent(
+                                    where = "uploadBatchSynchronously.postCGMData.fail",
+                                    message = contextData,
+                                    level = SentryLogLevel.WARN,
+                                    jsonPayload = json,
+                                    attributes = mapOf(
+                                        "batchIndex" to batchIndex.toString(),
+                                        "activeSensorId" to activeSensorId,
+                                        "payload_chars" to json.length.toString(),
+                                        "lastSync_glucoseId" to (lastSync?.glucoseId?.toString() ?: ""),
+                                        "lastSync_timeInMillis" to (lastSync?.timeInMillis?.toString() ?: "")
+                                    )
+                                )
+                            }
                             continuation.resume(false)
                         }
                     }
                 )
             } catch (e: Exception) {
                 Log.e("uploadBatchSynchronously", "Exception in batch $batchIndex: ${e.message}", e)
-                captureModuleException(
-                    "uploadBatchSynchronously",
-                    RuntimeException(
-                        "uploadBatchSynchronously failed | batchIndex=$batchIndex",
-                        e
+                safeLogModuleEvent {
+                    logModuleEvent(
+                        where = "uploadBatchSynchronously",
+                        message = "uploadBatchSynchronously failed | batchIndex=$batchIndex",
+                        throwable = e,
+                        level = SentryLogLevel.ERROR,
+                        jsonPayload = json,
+                        attributes = mapOf("batchIndex" to batchIndex.toString())
                     )
-                )
+                }
                 continuation.resume(false)
             }
         }
@@ -1392,7 +1749,9 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                         )
                     } catch (e: Exception) {
                         Log.e("updateSyncMetadata", "Error updating sync metadata: ${e.message}", e)
-                        captureModuleException("updateSyncMetadata", e)
+                        safeLogModuleEvent {
+                            logModuleEvent("updateSyncMetadata", throwable = e, level = SentryLogLevel.ERROR)
+                        }
                     }
                 }
             }
@@ -1412,48 +1771,46 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
     }
 
     fun mapToDto(glucose: PocGlucose): GlucoseLog {
-        val dto: GlucoseLog = GlucoseLog()
-        dto.timeInMillis = glucose.getTimeInMillis()
-        dto.countdownMinutes = glucose.getCountdownMinutes()
-        dto.countdownHours = glucose.getCountdownHours()
-        dto.countdownDays = glucose.getCountdownDays()
-        dto.hypoglycemiaEarlyWarnMinutes = glucose.getHypoglycemiaEarlyWarnMinutes()
-        dto.showGlucoseMG = glucose.getShowGlucoseMG()
-        dto.glucoseId = glucose.getGlucoseId()
-        dto.name = glucose.getName()
-        dto.showGlucose = glucose.getShowGlucose()
-        dto.Ib = glucose.getIb()
-        dto.Iw = glucose.getIw()
-        dto.T = glucose.getT()
-        dto.year = glucose.getYear()
-        dto.month = glucose.getMonth()
-        dto.day = glucose.getDay()
-        dto.hour = glucose.getHour()
-        dto.minute = glucose.getMinute()
-
-        // Convert byte[] to List<Integer>
+        val log = mapPocGlucoseToCgmLog(glucose)
+
+        val dto = GlucoseLog()
+        dto.timeInMillis = log.timeInMillis
+        dto.countdownMinutes = log.countdownMinutes
+        dto.countdownHours = log.countdownHours
+        dto.countdownDays = log.countdownDays
+        dto.hypoglycemiaEarlyWarnMinutes = log.hypoglycemiaEarlyWarnMinutes
+        dto.showGlucoseMG = log.showGlucoseMG
+        dto.glucoseId = log.glucoseId
+        dto.name = log.name
+        dto.showGlucose = log.showGlucose
+        dto.Ib = log.Ib
+        dto.Iw = log.Iw
+        dto.T = log.T
+        dto.year = log.year
+        dto.month = log.month
+        dto.day = log.day
+        dto.hour = log.hour
+        dto.minute = log.minute
+
         dto.bytes = ArrayList()
-        for (b in glucose.getBytes()) {
-            dto.bytes?.add(b.toInt() and 0xFF) // Prevent negative values
+        log.bytes?.forEach { b ->
+            dto.bytes?.add(b.toInt() and 0xFF)
         }
 
-        // Trend
-        val trendObj: TrendObject = TrendObject()
-        trendObj.trendId = glucose.getTrend().getTrendId()
-        trendObj.drawableId = glucose.getTrend().getDrawableId()
-        trendObj.widgetImg = glucose.getTrend().getWidgetImg()
-        trendObj.apsChangeRate = glucose.getTrend().getApsChangeRate()
+        val trendObj = GlucoseLog.TrendObject()
+        trendObj.trendId = log.trendObject.trendId
+        trendObj.drawableId = log.trendObject.drawableId
+        trendObj.widgetImg = log.trendObject.widgetImg
+        trendObj.apsChangeRate = log.trendObject.apsChangeRate
         dto.trendObject = trendObj
 
-        // Status
-        val statusObj: GlucoseStatusObject = GlucoseStatusObject()
-        statusObj.statusId = glucose.getGlucoseStatus().getStatusId()
+        val statusObj = GlucoseLog.GlucoseStatusObject()
+        statusObj.statusId = log.glucoseStatusObject.statusId
         dto.glucoseStatusObject = statusObj
 
-        // Error
-        val errorObj: ErrorObject = ErrorObject()
-        errorObj.errorId = glucose.getErrorCode().getErrorId()
-        errorObj.sound = glucose.getErrorCode().getSound().toString()
+        val errorObj = GlucoseLog.ErrorObject()
+        errorObj.errorId = log.errorObject.errorId
+        errorObj.sound = log.errorObject.sound.toString()
         dto.errorObject = errorObj
 
         return dto
@@ -1476,13 +1833,18 @@ class CgmTrackyLibModule(reactContext: ReactApplicationContext) :
                 ?.emit(eventName, map)
         } catch (e: Exception) {
             Log.e("Error sendDataToReact: ", e.message.toString(), e)
-            captureModuleException(
-                "sendDataToReact",
-                RuntimeException(
-                    "sendDataToReact failed | eventName=$eventName;status=$status",
-                    e
+            safeLogModuleEvent {
+                logModuleEvent(
+                    where = "sendDataToReact",
+                    message = "sendDataToReact failed | eventName=$eventName;status=$status",
+                    throwable = e,
+                    level = SentryLogLevel.ERROR,
+                    attributes = mapOf(
+                        "eventName" to eventName,
+                        "status" to status
+                    )
                 )
-            )
+            }
         }
     }