diff --git a/README.md b/README.md
index 913a876..a56f79e 100644
--- a/README.md
+++ b/README.md
@@ -223,8 +223,79 @@ val retrofit = Retrofit.Builder().build("your_baseUrl", okHttpClient gsonConvert
 </li>
 </ul>
 
+### Event Logger
+
+A remote troubleshooting utility which helps to track or send important events to a remote API server.
+This is intended to be used internally by Rakuten's SDKs.
+
+<ul>
+<li>
+
+```configure```: Sets the server configuration and other initialization processing. Call this as early as possible in the application lifecycle, such as `onCreate` or other initialization methods. Calling other APIs without calling this API has no effect.
+
+| Parameter | Description              | Datatype | Required? |
+|-----------| ------------------------ |----------|-----------|
+| context   | Application context      | Context  | `Yes`     |
+| apiUrl    | Non-empty server API URL | String   | `Yes`     |
+| apiKey    | Non-empty server API Key | String   | `Yes`     |
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+    // API: configure
+    EventLogger.configure(this, "my-api-url", "my-api-key")
+}
+
+```
+
+</li>
+
+<li>
+
+```send*Event```: Logs an event and sends to server based on criticality.
+
+| Parameter | Description | Datatype | Required? |
+|----------|---------|----------|-----------|
+| sourceName | Non-empty source of the event, e.g. "sdkutils" | String | `Yes` |
+| sourceVersion | Non-empty source' version, e.g. "2.0.0" | String | `Yes` |
+| errorCode | Non-empty source' error code or HTTP backend response code e.g. "500" | String | `Yes` |
+| errorMessage | Non-empty description of the error. Make it as descriptive as possible, for example, the stacktrace of an exception | String | `Yes` |
+| info | Optional parameter to attach other useful key-value pair, such as filename, method, line number, etc. | Map | `No` |
+
+```kotlin
+
+// API: sendCriticalEvent
+// Logs a critical event, wherein the unique event will be sent to the server immediately.
+EventLogger.sendCriticalEvent(
+    sourceName = "sdkutils",
+    sourceVersion = "2.0.0",
+    errorCode = "XXX",
+    errorMessage = "java.lang.ArithmeticException: divide by zero
+                    at com.rakuten.test.MainActivityFragment.onViewCreated(MainActivityFragment.kt:58)
+                    at androidx.fragment.app.FragmentManagerImpl.ensureInflatedFragmentView(FragmentManagerImpl.java:1144)
+                    at androidx.fragment.app.FragmentManagerImpl.moveToState(FragmentManagerImpl.java:851)"
+    info = mapOf("filename" to "MyFile.kt")
+)
+
+// API: sendWarningEvent
+// Logs a warning event, which will be sent at a later time based on TTL.
+EventLogger.sendWarningEvent(
+    sourceName = "sdkutils",
+    sourceVersion = "2.0.0",
+    errorCode = "YYY",
+    errorMessage = "Incorrect credentials",
+    info = mapOf("filename" to "MyFile.kt")
+)
+
+```
+
+</li>
+<li>
+
 ## Changelog
 
+### v2.2.0 (In-Progress)
+* SDKCF-6859: Added `EventLogger` feature which sends events to a remote API server. It is intended to be used internally by Rakuten's SDKs. See [Event Logger](#event-logger) section for details.
+
 ### v2.1.1 (2022-08-04)
 * SDKCF-5737: Reverted `Logger` constructor to single parameter.
 
diff --git a/sample/build.gradle b/sample/build.gradle
index 032a000..c48a70d 100644
--- a/sample/build.gradle
+++ b/sample/build.gradle
@@ -13,6 +13,11 @@ android {
     versionCode 1
     versionName "1.0"
     minSdkVersion 23
+
+    buildConfigField("String", "EVENT_LOGGER_API_URL_PRD", "\"${property("EVENT_LOGGER_API_URL_PRD")}\"")
+    buildConfigField("String", "EVENT_LOGGER_API_URL_STG", "\"${property("EVENT_LOGGER_API_URL_STG")}\"")
+    buildConfigField("String", "EVENT_LOGGER_API_KEY_PRD", "\"${property("EVENT_LOGGER_API_KEY_PRD")}\"")
+    buildConfigField("String", "EVENT_LOGGER_API_KEY_STG", "\"${property("EVENT_LOGGER_API_KEY_STG")}\"")
   }
 
   sourceSets.each {
@@ -43,10 +48,18 @@ android {
   }
 
   buildTypes {
+    debug {
+      buildConfigField("String", "EVENT_LOGGER_API_URL", "\"${property("EVENT_LOGGER_API_URL_STG")}\"")
+      buildConfigField("String", "EVENT_LOGGER_API_KEY", "\"${property("EVENT_LOGGER_API_KEY_STG")}\"")
+    }
+
     release {
       minifyEnabled true
       debuggable false
       signingConfig signingConfigs.release
+
+      buildConfigField("String", "EVENT_LOGGER_API_URL", "\"${property("EVENT_LOGGER_API_URL_PRD")}\"")
+      buildConfigField("String", "EVENT_LOGGER_API_KEY", "\"${property("EVENT_LOGGER_API_KEY_PRD")}\"")
     }
   }
 }
@@ -56,6 +69,7 @@ dependencies {
   implementation 'androidx.constraintlayout:constraintlayout:2.0.0-beta3'
   implementation "com.squareup.okhttp3:okhttp:$CONFIG.versions.okhttp"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"
+  implementation 'com.google.code.gson:gson:2.8.9'
   implementation project(':sdk-utils')
 }
 
diff --git a/sample/src/main/AndroidManifest.xml b/sample/src/main/AndroidManifest.xml
index 6b20c2c..3c79e80 100644
--- a/sample/src/main/AndroidManifest.xml
+++ b/sample/src/main/AndroidManifest.xml
@@ -13,14 +13,27 @@
     android:networkSecurityConfig="@xml/network_security_config"
     tools:ignore="GoogleAppIndexingWarning">
 
-    <activity android:name=".MainActivity"
+    <activity
+        android:name=".MainActivity"
+        android:label="SDK Utils Sample"
         android:exported="true">
       <intent-filter>
         <action android:name="android.intent.action.MAIN"/>
-
         <category android:name="android.intent.category.LAUNCHER"/>
       </intent-filter>
     </activity>
+
+    <activity
+        android:name=".EventLoggerActivity"
+        android:label="Event Logger"
+        android:exported="true">
+    </activity>
+
+    <activity
+        android:name=".EventLoggerCacheActivity"
+        android:label="Event Logger Cache"
+        android:exported="true">
+    </activity>
   </application>
 
 </manifest>
\ No newline at end of file
diff --git a/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerActivity.kt b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerActivity.kt
new file mode 100644
index 0000000..4e1f67e
--- /dev/null
+++ b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerActivity.kt
@@ -0,0 +1,132 @@
+package com.rakuten.tech.mobile.sdkutils.sample
+
+import android.content.Intent
+import android.os.Bundle
+import android.widget.RadioButton
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import androidx.databinding.DataBindingUtil
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.google.gson.reflect.TypeToken
+import com.rakuten.tech.mobile.sdkutils.eventlogger.EventLogger
+import com.rakuten.tech.mobile.sdkutils.sample.databinding.ActivityEventLoggerBinding
+import kotlin.random.Random
+
+@Suppress(
+    "UndocumentedPublicClass",
+    "UndocumentedPublicFunction",
+    "MagicNumber",
+    "TooManyFunctions"
+)
+class EventLoggerActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivityEventLoggerBinding
+    private val sdkName
+        get() = binding.sdkNameText.text.toString().ifEmpty { "sdkutils" }
+    private val sdkVersion
+        get() = binding.sdkVerText.text.toString().ifEmpty { com.rakuten.tech.mobile.sdkutils.BuildConfig.VERSION_NAME }
+    private val errorCode
+        get() = binding.errorCodeText.text.toString()
+    private val errorMessage
+        get() = binding.errorMsgText.text.toString()
+    private val numTimes
+        get() = binding.numTimesText.text.toString().toIntOrNull() ?: 1
+    private val eventTypeRadId
+        get() = binding.eventTypeRadioGrp.checkedRadioButtonId
+    private val eventType
+        get() = findViewById<RadioButton>(eventTypeRadId).text.toString().lowercase()
+    private val infoString
+        get() = binding.addtnlInfoText.text.toString()
+    private val info: Map<String, String>?
+        get() = if (infoString.isEmpty()) null else jsonStringToMap(infoString)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        binding = DataBindingUtil.setContentView(this, R.layout.activity_event_logger)
+        binding.activity = this
+        setDefaultsOrHints()
+
+        EventLogger.configure(this, BuildConfig.EVENT_LOGGER_API_URL, BuildConfig.EVENT_LOGGER_API_KEY)
+    }
+
+    fun onLogEventButtonClick() {
+        logEvent()
+    }
+
+    fun onLogUniqueEventButtonClick() {
+        logEvent(true)
+    }
+
+    fun onCustomButtonClick() {
+        binding.errorMsgText.setText("")
+    }
+
+    fun onException1ButtonClick() {
+        binding.errorMsgText.setText(
+            ArithmeticException().stackTraceToString().take(1000)
+        )
+    }
+
+    fun onException2ButtonClick() {
+        binding.errorMsgText.setText(
+            IllegalArgumentException("Testing").stackTraceToString().take(1000)
+        )
+    }
+
+    fun onShowEventsCacheClick() {
+        val intent = Intent(this, EventLoggerCacheActivity::class.java)
+        this.startActivity(intent)
+    }
+
+    private fun setDefaultsOrHints() {
+        binding.apply {
+            sdkNameText.setText("sdkutils")
+            sdkVerText.setText(com.rakuten.tech.mobile.sdkutils.BuildConfig.VERSION_NAME)
+            numTimesText.setText("1")
+            addtnlInfoText.hint = """{ "key": "value" }"""
+        }
+    }
+
+    @SuppressWarnings("LongMethod")
+    private fun logEvent(randomizeMessage: Boolean = false) {
+        when (eventType) {
+            "critical" -> repeat(numTimes) {
+                EventLogger.sendCriticalEvent(
+                    sourceName = sdkName,
+                    sourceVersion = sdkVersion,
+                    errorCode = errorCode,
+                    errorMessage = if (randomizeMessage) randomizeString() else errorMessage,
+                    info = info
+                )
+            }
+            "warning" -> repeat(numTimes) {
+                EventLogger.sendWarningEvent(
+                    sourceName = sdkName,
+                    sourceVersion = sdkVersion,
+                    errorCode = errorCode,
+                    errorMessage = if (randomizeMessage) randomizeString() else errorMessage,
+                    info = info
+                )
+            }
+        }
+
+        Toast.makeText(this, "Processed!", Toast.LENGTH_SHORT).show()
+    }
+
+    @SuppressWarnings("SwallowedException")
+    private fun jsonStringToMap(jsonString: String): Map<String, String>? {
+        val type = object : TypeToken<Map<String, String>>() {}.type
+        return try {
+            Gson().fromJson(jsonString, type)
+        } catch (e: JsonSyntaxException) {
+            Toast.makeText(this, "Not a valid Json representation!", Toast.LENGTH_SHORT).show()
+            return null
+        }
+    }
+
+    private fun randomizeString(length: Int = 20) = (1..length)
+        .map { Random.nextInt(33, 127).toChar() } // Ascii alphanumeric + some special characters range
+        .joinToString("")
+}
diff --git a/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerCacheActivity.kt b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerCacheActivity.kt
new file mode 100644
index 0000000..a4e4c23
--- /dev/null
+++ b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/EventLoggerCacheActivity.kt
@@ -0,0 +1,50 @@
+package com.rakuten.tech.mobile.sdkutils.sample
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.databinding.DataBindingUtil
+import com.rakuten.tech.mobile.sdkutils.sample.databinding.ActivityEventLoggerCacheBinding
+import org.json.JSONObject
+
+@Suppress(
+    "UndocumentedPublicClass",
+    "MagicNumber"
+)
+class EventLoggerCacheActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivityEventLoggerCacheBinding
+    private lateinit var eventsCache: SharedPreferences
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        binding = DataBindingUtil.setContentView(this, R.layout.activity_event_logger_cache)
+        eventsCache = this
+            .getSharedPreferences("com.rakuten.tech.mobile.sdkutils.eventlogger.events", Context.MODE_PRIVATE)
+        setCacheText()
+    }
+
+    private fun setCacheText() {
+
+        if (eventsCache.all.isEmpty()) {
+            binding.numEventsLabel.text = "Count: 0"
+            return
+        }
+
+        val textBuilder = StringBuilder(0)
+        val allEvents = eventsCache.all
+        binding.numEventsLabel.text = "Count: ${allEvents.size}"
+        for (event in allEvents) {
+            textBuilder.append(event.key)
+            textBuilder.append("\n")
+            textBuilder.append(
+                JSONObject(event.value.toString()).toString(4)
+            )
+            textBuilder.append("\n\n\n")
+        }
+
+        binding.eventsStorageText.text = textBuilder
+    }
+}
diff --git a/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/MainActivity.kt b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/MainActivity.kt
index de63e7f..ac4800b 100644
--- a/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/MainActivity.kt
+++ b/sample/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/sample/MainActivity.kt
@@ -1,8 +1,9 @@
 package com.rakuten.tech.mobile.sdkutils.sample
 
-import android.app.Activity
+import android.content.Intent
 import android.os.Bundle
 import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
 import androidx.databinding.DataBindingUtil
 import com.rakuten.tech.mobile.sdkutils.PreferencesUtil
 import com.rakuten.tech.mobile.sdkutils.logger.Logger
@@ -20,7 +21,7 @@ import okhttp3.Response
 import java.util.Date
 
 @Suppress("UndocumentedPublicClass", "UndocumentedPublicFunction", "SpreadOperator")
-class MainActivity : Activity() {
+class MainActivity : AppCompatActivity() {
 
     private lateinit var binding: ActivityMainBinding
     private val log = Logger(MainActivity::class.java.simpleName)
@@ -75,6 +76,11 @@ class MainActivity : Activity() {
         })
     }
 
+    fun onEventLoggerButtonClick() {
+        val intent = Intent(this, EventLoggerActivity::class.java)
+        this.startActivity(intent)
+    }
+
     private fun showToast(message: String) =
         Toast.makeText(this, message, Toast.LENGTH_SHORT)
             .show()
diff --git a/sample/src/main/res/layout/activity_event_logger.xml b/sample/src/main/res/layout/activity_event_logger.xml
new file mode 100644
index 0000000..433207b
--- /dev/null
+++ b/sample/src/main/res/layout/activity_event_logger.xml
@@ -0,0 +1,251 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    tools:ignore="HardcodedText"
+    tools:context=".EventLoggerActivity">
+    <data>
+        <variable
+            name="activity"
+            type="com.rakuten.tech.mobile.sdkutils.sample.EventLoggerActivity"/>
+    </data>
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_margin="20dp" >
+
+        <LinearLayout
+            android:id="@+id/log_event_container"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical" >
+
+            <TableLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:stretchColumns="*">
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+
+                    <TextView
+                        android:id="@+id/sdk_name_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="SDK Name" />
+
+                    <EditText
+                        android:id="@+id/sdk_name_text"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"/>
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+                    <TextView
+                        android:id="@+id/sdk_ver_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="SDK Version" />
+
+                    <EditText
+                        android:id="@+id/sdk_ver_text"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content" />
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+                    <TextView
+                        android:id="@+id/error_code_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="Error Code" />
+
+                    <EditText
+                        android:id="@+id/error_code_text"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content" />
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+
+                    <TextView
+                        android:id="@+id/error_msg_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="Error Message" />
+
+                    <LinearLayout
+                        android:orientation="vertical"
+                        android:layout_width="0dp"
+                        android:layout_weight="2" >
+
+                        <RadioGroup
+                            android:id="@+id/event_msg_radio_grp"
+                            android:layout_weight="1"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:checkedButton="@id/custom_error_message_button"
+                            android:orientation="horizontal" >
+
+                            <RadioButton
+                                android:id="@+id/custom_error_message_button"
+                                android:layout_width="wrap_content"
+                                android:layout_height="wrap_content"
+                                android:text="Custom"
+                                android:onClick="@{() -> activity.onCustomButtonClick()}" />
+
+                            <RadioButton
+                                android:id="@+id/arithmetic_exception_button"
+                                android:layout_width="wrap_content"
+                                android:layout_height="wrap_content"
+                                android:text="Err1"
+                                android:onClick="@{() -> activity.onException1ButtonClick()}" />
+
+                            <RadioButton
+                                android:id="@+id/illegal_argument_exception_button"
+                                android:layout_width="wrap_content"
+                                android:layout_height="wrap_content"
+                                android:text="Err2"
+                                android:onClick="@{() -> activity.onException2ButtonClick()}" />
+
+                        </RadioGroup>
+
+                        <EditText
+                            android:inputType="textMultiLine"
+                            android:maxLines="2"
+                            android:id="@+id/error_msg_text"
+                            android:layout_weight="1"
+                            android:layout_width="match_parent"
+                            android:layout_height="wrap_content" />
+                    </LinearLayout>
+
+
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+                    <TextView
+                        android:id="@+id/num_times_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="# of Times" />
+
+                    <EditText
+                        android:id="@+id/num_times_text"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content" />
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+
+                    <TextView
+                        android:id="@+id/event_type_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="Event Type" />
+
+                    <RadioGroup
+                        android:id="@+id/event_type_radio_grp"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:checkedButton="@id/warning_button"
+                        android:orientation="horizontal" >
+
+                        <RadioButton
+                            android:id="@+id/warning_button"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:text="Warning" />
+
+                        <RadioButton
+                            android:id="@+id/critical_button"
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:text="Critical" />
+
+                    </RadioGroup>
+                </TableRow>
+
+                <TableRow>
+                    <TextView
+                        android:id="@+id/addtnl_info_label"
+                        android:layout_weight="1"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:text="Additional Info" />
+
+                    <EditText
+                        android:id="@+id/addtnl_info_text"
+                        android:layout_weight="2"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"/>
+                </TableRow>
+
+                <TableRow
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content" >
+
+                    <Button
+                        android:id="@+id/log_event"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="2"
+                        android:textStyle="bold"
+                        android:text="Log Event"
+                        android:onClick="@{() -> activity.onLogEventButtonClick()}" />
+                </TableRow>
+            </TableLayout>
+
+            <TableRow
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" >
+
+                <Button
+                    android:id="@+id/log_unique_events"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:textStyle="bold"
+                    android:text="Log Unique Event/s\n(randomize Error Message)"
+                    android:onClick="@{() -> activity.onLogUniqueEventButtonClick()}" />
+            </TableRow>
+
+            <TableRow
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" >
+
+                <Button
+                    android:id="@+id/show_events_cache"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:textStyle="bold"
+                    android:text="Show/sync events storage"
+                    android:onClick="@{() -> activity.onShowEventsCacheClick()}" />
+            </TableRow>
+
+        </LinearLayout>
+
+    </RelativeLayout>
+</layout>
diff --git a/sample/src/main/res/layout/activity_event_logger_cache.xml b/sample/src/main/res/layout/activity_event_logger_cache.xml
new file mode 100644
index 0000000..35d298f
--- /dev/null
+++ b/sample/src/main/res/layout/activity_event_logger_cache.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:context=".EventLoggerCacheActivity">
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" >
+
+        <TextView
+            android:id="@+id/num_events_label"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_margin="8dp"
+            android:textSize="20dp"
+            tools:text="Count: XXX" />
+
+        <ScrollView
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_below="@id/num_events_label" >
+
+            <TextView
+                android:id="@+id/events_storage_text"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_margin="8dp" />
+        </ScrollView>
+
+    </RelativeLayout>
+
+</layout>
+
diff --git a/sample/src/main/res/layout/activity_main.xml b/sample/src/main/res/layout/activity_main.xml
index 117ca6b..8a320ff 100644
--- a/sample/src/main/res/layout/activity_main.xml
+++ b/sample/src/main/res/layout/activity_main.xml
@@ -43,5 +43,14 @@
         android:layout_height="wrap_content"
         android:onClick="@{() -> activity.onAppInfoButtonClick()}"
         android:text="Show App Info"/>
+
+    <Button
+        android:id="@+id/eventLoggerButton"
+        app:layout_constraintTop_toBottomOf="@id/appInfoButton"
+        android:textStyle="bold"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:onClick="@{() -> activity.onEventLoggerButtonClick()}"
+        android:text="Event Logger"/>
   </androidx.constraintlayout.widget.ConstraintLayout>
 </layout>
diff --git a/sample/src/main/res/values/styles.xml b/sample/src/main/res/values/styles.xml
index 705be27..54b878f 100644
--- a/sample/src/main/res/values/styles.xml
+++ b/sample/src/main/res/values/styles.xml
@@ -3,6 +3,8 @@
   <!-- Base application theme. -->
   <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
     <!-- Customize your theme here. -->
+    <item name="android:windowActionBar">true</item>
+    <item name="windowNoTitle">false</item>
     <item name="colorPrimary">@color/colorPrimary</item>
     <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
     <item name="colorAccent">@color/colorAccent</item>
diff --git a/sdk-utils/build.gradle b/sdk-utils/build.gradle
index 7895a71..ed519f4 100644
--- a/sdk-utils/build.gradle
+++ b/sdk-utils/build.gradle
@@ -5,6 +5,7 @@ apply plugin: 'kotlin-kapt'
 
 android {
   defaultConfig {
+    consumerProguardFiles "proguard-rules.pro"
     resValue 'string', 'sdk_utils__version', project.version
   }
 
@@ -34,7 +35,6 @@ dependencies {
   implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
   implementation 'com.squareup.retrofit2:retrofit:2.9.0'
   implementation 'com.google.code.gson:gson:2.8.9'
-  implementation "com.google.code.gson:gson:$CONFIG.versions.thirdParty.gson"
   implementation 'com.google.android.gms:play-services-base:17.0.0'
 
   testImplementation 'junit:junit:4.13.2'
diff --git a/sdk-utils/proguard-rules.pro b/sdk-utils/proguard-rules.pro
new file mode 100644
index 0000000..7f2d206
--- /dev/null
+++ b/sdk-utils/proguard-rules.pro
@@ -0,0 +1,137 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+
+###################
+#                 #
+#  Project rules  #
+#                 #
+###################
+
+# Public class
+-keepattributes !*Annotation*
+-keep class com.rakuten.tech.mobile.sdkutils.eventlogger.Event { *; }
+
+###################
+#                 #
+#  Dependencies   #
+#                 #
+###################
+
+##------------------------------------------- Retrofit  -----------------------------------
+
+# see https://github.com/square/retrofit/blob/master/retrofit/src/main/resources/META-INF/proguard/retrofit2.pro
+# Retrofit does reflection on generic parameters. InnerClasses is required to use Signature and
+# EnclosingMethod is required to use InnerClasses.
+-keepattributes Signature, InnerClasses, EnclosingMethod
+
+# Retrofit does reflection on method and parameter annotations.
+-keepattributes RuntimeVisibleAnnotations, RuntimeVisibleParameterAnnotations
+
+# Keep annotation default values (e.g., retrofit2.http.Field.encoded).
+-keepattributes AnnotationDefault
+
+# Retain service method parameters when optimizing.
+-keepclassmembers,allowshrinking,allowobfuscation interface * {
+    @retrofit2.http.* <methods>;
+}
+
+# Ignore annotation used for build tooling.
+#-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+
+# Ignore JSR 305 annotations for embedding nullability information.
+-dontwarn javax.annotation.**
+
+# Guarded by a NoClassDefFoundError try/catch and only used when on the classpath.
+-dontwarn kotlin.Unit
+
+# Top-level functions that can only be used by Kotlin.
+-dontwarn retrofit2.KotlinExtensions
+-dontwarn retrofit2.KotlinExtensions$*
+
+# With R8 full mode, it sees no subtypes of Retrofit interfaces since they are created with a Proxy
+# and replaces all potential values with null. Explicitly keeping the interfaces prevents this.
+-if interface * { @retrofit2.http.* <methods>; }
+-keep,allowobfuscation interface <1>
+
+# Keep inherited services.
+-if interface * { @retrofit2.http.* <methods>; }
+-keep,allowobfuscation interface * extends <1>
+
+# With R8 full mode generic signatures are stripped for classes that are not
+# kept. Suspend functions are wrapped in continuations where the type argument
+# is used.
+-keep,allowobfuscation,allowshrinking class kotlin.coroutines.Continuation
+
+# R8 full mode strips generic signatures from return types if not kept.
+-if interface * { @retrofit2.http.* public *** *(...); }
+-keep,allowoptimization,allowshrinking,allowobfuscation class <3>
+
+
+##------------------------------------------- Gson  -----------------------------------
+
+# see https://github.com/google/gson/blob/master/examples/android-proguard-example/proguard.cfg
+# Gson uses generic type information stored in a class file when working with fields. Proguard
+# removes such information by default, so configure it to keep all of it.
+#-keepattributes Signature
+
+# For using GSON @Expose annotation
+-keepattributes *Annotation*
+
+# Gson specific classes
+-dontwarn sun.misc.**
+#-keep class com.google.gson.stream.** { *; }
+
+# Application classes that will be serialized/deserialized over Gson
+-keep class com.google.gson.examples.android.model.** { <fields>; }
+
+# Prevent proguard from stripping interface information from TypeAdapter, TypeAdapterFactory,
+# JsonSerializer, JsonDeserializer instances (so they can be used in @JsonAdapter)
+-keep class * extends com.google.gson.TypeAdapter
+-keep class * implements com.google.gson.TypeAdapterFactory
+-keep class * implements com.google.gson.JsonSerializer
+-keep class * implements com.google.gson.JsonDeserializer
+
+# Prevent R8 from leaving Data object members always null
+-keepclassmembers,allowobfuscation class * {
+  @com.google.gson.annotations.SerializedName <fields>;
+}
+
+# Retain generic signatures of TypeToken and its subclasses with R8 version 3.0 and higher.
+-keep,allowobfuscation,allowshrinking class com.google.gson.reflect.TypeToken
+-keep,allowobfuscation,allowshrinking class * extends com.google.gson.reflect.TypeToken
+
+##------------------------------------------- Others  -----------------------------------
+
+# JSR 305 annotations are for embedding nullability information.
+-dontwarn javax.annotation.**
+
+# A resource is loaded with a relative path so the package of this class must be preserved.
+-adaptresourcefilenames okhttp3/internal/publicsuffix/PublicSuffixDatabase.gz
+
+# Animal Sniffer compileOnly dependency to ensure APIs are compatible with older versions of Java.
+-dontwarn org.codehaus.mojo.animal_sniffer.*
+
+# OkHttp platform used only on JVM and when Conscrypt and other security providers are available.
+-dontwarn okhttp3.internal.platform.**
+-dontwarn org.conscrypt.**
+-dontwarn org.bouncycastle.**
+-dontwarn org.openjsse.**
\ No newline at end of file
diff --git a/sdk-utils/src/main/AndroidManifest.xml b/sdk-utils/src/main/AndroidManifest.xml
index a02f0a2..4f70ea4 100644
--- a/sdk-utils/src/main/AndroidManifest.xml
+++ b/sdk-utils/src/main/AndroidManifest.xml
@@ -2,6 +2,8 @@
 <manifest package="com.rakuten.tech.mobile.sdkutils"
   xmlns:android="http://schemas.android.com/apk/res/android">
 
+  <uses-permission android:name="android.permission.INTERNET" />
+
   <application>
     <!-- It is not recommended to override the `initOrder`, however,
     if you need to manually set it, make sure that it is initialized before your own
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserver.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserver.kt
new file mode 100644
index 0000000..45fec1d
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserver.kt
@@ -0,0 +1,81 @@
+package com.rakuten.tech.mobile.sdkutils
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.os.Bundle
+import java.lang.ref.WeakReference
+
+/**
+ * Listener that should be registered to the [AppLifecycleObserver.registerListener] to be notified
+ * of desired application lifecycle callbacks.
+ */
+@SuppressWarnings("kotlin:S6517")
+interface LifecycleListener {
+    /**
+     * Called when app transitioned from background to foreground.
+     */
+    fun becameForeground() { /* default: do nothing */ }
+}
+
+/**
+ * Observes to application lifecycle callbacks.
+ */
+class AppLifecycleObserver(private val context: WeakReference<Context>) {
+
+    private lateinit var lifecycleCallback: LifecycleCallback
+    private val listeners = mutableListOf<LifecycleListener>()
+
+    /**
+     * Registers [listener] to be notified of app lifecycle callbacks.
+     */
+    fun registerListener(listener: LifecycleListener) {
+        if (!this::lifecycleCallback.isInitialized) {
+            lifecycleCallback = LifecycleCallback()
+
+            val app = context.get()?.applicationContext as? Application
+            app?.registerActivityLifecycleCallbacks(lifecycleCallback)
+        }
+
+        if (listener !in listeners) {
+            listeners.add(listener)
+        }
+    }
+
+    private fun notifyOnBecameForeground() {
+        listeners.forEach {
+            try {
+                it.becameForeground()
+            } catch (_: Exception) {
+                // do nothing
+            }
+        }
+    }
+
+    private inner class LifecycleCallback : Application.ActivityLifecycleCallbacks {
+        private var isInBackground = false
+
+        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+
+        override fun onActivityStarted(activity: Activity) = Unit
+
+        override fun onActivityResumed(activity: Activity) {
+            if (isInBackground) {
+                isInBackground = false
+                notifyOnBecameForeground()
+            }
+        }
+
+        override fun onActivityPaused(activity: Activity) = Unit
+
+        override fun onActivityStopped(activity: Activity) {
+            isInBackground = true
+        }
+
+        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+
+        override fun onActivityDestroyed(activity: Activity) {
+            isInBackground = false
+        }
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtension.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtension.kt
index 440033c..7d0922d 100644
--- a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtension.kt
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtension.kt
@@ -142,4 +142,18 @@ object StringExtension {
             ""
         }
     }
+
+    /**
+     * Sanitizes the input string by the following rules:
+     * - Removes tabs
+     * - Removes leading/trailing spaces
+     * - Optionally trims based on [maxLength] or retains the original string length if supplied [maxLength]
+     * is negative.
+     */
+    fun String.sanitize(maxLength: Int = this.length): String {
+        return this
+            .replace("\t", "")
+            .trim()
+            .take(if (maxLength < 0) this.length else maxLength)
+    }
 }
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/Event.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/Event.kt
new file mode 100644
index 0000000..418dc11
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/Event.kt
@@ -0,0 +1,63 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import com.google.gson.annotations.SerializedName
+import com.rakuten.tech.mobile.sdkutils.StringExtension.getMD5HashData
+
+internal data class Event(
+    var eventType: String,
+    val appId: String,
+    val appName: String,
+    val appVersion: String,
+    val osVersion: String,
+    val deviceModel: String,
+    val deviceBrand: String,
+    val deviceName: String,
+    val sdkName: String,
+    val sdkVersion: String,
+    val errorCode: String,
+    val errorMessage: String,
+    val rmcSdks: Map<String, String>? = null,
+    val info: Map<String, String>? = null,
+    var occurrenceCount: Int = 0,
+    val eventVersion: String = "1.0",
+    val platform: String = "Android",
+    @SerializedName("firstOccurrenceOn") val createdOn: Long = System.currentTimeMillis()
+)
+
+// ---------------------------- Event enums ----------------------------
+internal enum class EventType(val displayName: String) {
+    CRITICAL("0"),
+    WARNING("1")
+}
+
+// ---------------------------- Event extensions ----------------------------
+/**
+ * Returns the string hash based on some data from the [Event].
+ */
+internal fun Event.generateEventIdentifier() = generateEventIdentifier(
+    eventType,
+    appVersion,
+    sdkName,
+    errorCode,
+    errorMessage
+)
+
+/**
+ * Returns the MD5 hash data based off the combined string of the supplied parameters. In case it fails to generate hash
+ * data (which should not happen), the original combined string is returned trimmed to 32 characters.
+ */
+@SuppressWarnings("MagicNumber")
+internal fun generateEventIdentifier(
+    eventType: String,
+    appVersion: String,
+    sdkName: String,
+    errorCode: String,
+    errorMessage: String
+): String {
+    val origData = "$eventType$appVersion$sdkName$errorCode$errorMessage"
+    return origData.getMD5HashData() ?: origData.take(32)
+}
+
+internal fun Event.incrementCount() = apply { occurrenceCount += 1 }
+
+internal fun Event.setType(newType: String) = apply { eventType = newType }
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLogger.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLogger.kt
new file mode 100644
index 0000000..375c922
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLogger.kt
@@ -0,0 +1,308 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import androidx.annotation.VisibleForTesting
+import com.rakuten.tech.mobile.sdkutils.AppLifecycleObserver
+import com.rakuten.tech.mobile.sdkutils.BuildConfig
+import com.rakuten.tech.mobile.sdkutils.LifecycleListener
+import com.rakuten.tech.mobile.sdkutils.logger.Logger
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+import java.lang.ref.WeakReference
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+/**
+ * A remote logging utility that sends events to the Event Logger platform.
+ * This is intended to be used internally by Rakuten's SDKs.
+ */
+@SuppressWarnings(
+    "TooManyFunctions",
+    "LargeClass"
+)
+object EventLogger {
+
+    internal val log = Logger(EventLogger::class.java.simpleName).apply { setDebug(BuildConfig.DEBUG) }
+
+    private lateinit var eventsSender: EventsSender
+    private lateinit var eventsStorage: EventsStorage
+    private lateinit var eventLoggerCache: EventLoggerCache
+    private lateinit var eventLoggerHelper: EventLoggerHelper
+    private lateinit var executorService: ExecutorService
+    @Volatile private var isConfigureCalled = false
+
+    // ------------------------------------Public APIs-----------------------------------------------
+
+    /**
+     * Initializes the event logging utility. Call this as early as possible in the application lifecycle, such as
+     * `onCreate` or other initialization methods.
+     *
+     * @param context Application context.
+     * @param apiUrl Server API URL.
+     * @param apiKey Server API Key.
+     */
+    @Synchronized
+    fun configure(
+        context: Context,
+        apiUrl: String,
+        apiKey: String
+    ) {
+        if (isConfigureCalled) {
+            log.debug("Event Logger has been configured already")
+            return
+        }
+
+        if (apiUrl.isEmpty() || apiKey.isEmpty()) {
+            log.warn("Event Logger cannot be configured due to empty API URL or key")
+            return
+        }
+
+        initialize(context, apiUrl, apiKey)
+    }
+
+    /**
+     * Logs a critical event - an error that may cause the caller to not function properly. This event is sent
+     * automatically.
+     *
+     * @param sourceName Source of the event, e.g. "inappmessaging".
+     * @param sourceVersion Source' version, e.g. "1.0.0".
+     * @param errorCode Source' error code or HTTP backend response code e.g. "500".
+     * @param errorMessage Description of the error. Make it as descriptive as possible, for example, the stacktrace
+     * of an exception.
+     * @param info Optional parameter to attach other useful key-value pair, such as filename, method, line number, etc.
+     */
+    fun sendCriticalEvent(
+        sourceName: String,
+        sourceVersion: String,
+        errorCode: String,
+        errorMessage: String,
+        info: Map<String, String>? = null
+    ) {
+        logEvent(EventType.CRITICAL, sourceName, sourceVersion, errorCode, errorMessage, info)
+    }
+
+    /**
+     * Logs a warning event - an unexpected situation that the caller can recover from. This event is sent at a later
+     * time.
+     *
+     * @param sourceName Source of the event, e.g. "inappmessaging".
+     * @param sourceVersion Source' version, e.g. "1.0.0".
+     * @param errorCode Source' error code or HTTP backend response code e.g. "500".
+     * @param errorMessage Description of the error. Make it as descriptive as possible, for example, the stacktrace
+     * of an exception.
+     * @param info Optional parameter to attach other useful key-value pair, such as filename, method, line number, etc.
+     */
+    fun sendWarningEvent(
+        sourceName: String,
+        sourceVersion: String,
+        errorCode: String,
+        errorMessage: String,
+        info: Map<String, String>? = null
+    ) {
+        logEvent(EventType.WARNING, sourceName, sourceVersion, errorCode, errorMessage, info)
+    }
+
+    // ------------------------------------Internal APIs-----------------------------------------------
+
+    private fun buildEventLoggerHttpClient(baseUrl: String): Retrofit {
+        return Retrofit
+            .Builder()
+            .baseUrl(if (baseUrl.endsWith('/')) baseUrl else "$baseUrl/")
+            .addConverterFactory(GsonConverterFactory.create())
+            .build()
+    }
+
+    private fun initialize(
+        context: Context,
+        apiUrl: String,
+        apiKey: String
+    ) {
+        // Build dependencies
+        initialize(
+            eventsSender = RetrofitEventsSender(
+                buildEventLoggerHttpClient(apiUrl).create(RetrofitEventsSender.Api::class.java),
+                apiKey
+            ),
+            eventsStorage = SharedPreferencesEventsStorage(
+                context.getSharedPreferences(Config.EVENTS_STORAGE_FILENAME, Context.MODE_PRIVATE)
+            ),
+            eventLoggerCache = SharedPreferencesEventLoggerCache(
+                context.getSharedPreferences(Config.EVENT_LOGGER_GENERAL_CACHE_FILENAME, Context.MODE_PRIVATE)
+            ),
+            eventLoggerHelper = EventLoggerHelper(WeakReference(context.applicationContext)),
+            appLifecycleObserver = AppLifecycleObserver(WeakReference(context.applicationContext)),
+            executorService = Executors.newSingleThreadExecutor()
+        )
+    }
+
+    /**
+     * Registers to the background to foreground app transition and if the TTL expired, will send all events in storage.
+     */
+    @VisibleForTesting
+    @Synchronized
+    @SuppressWarnings(
+        "LongParameterList"
+    )
+    internal fun initialize(
+        eventsSender: EventsSender,
+        eventsStorage: EventsStorage,
+        eventLoggerCache: EventLoggerCache,
+        eventLoggerHelper: EventLoggerHelper,
+        appLifecycleObserver: AppLifecycleObserver,
+        executorService: ExecutorService
+    ) {
+        this.eventsSender = eventsSender
+        this.eventsStorage = eventsStorage
+        this.eventLoggerCache = eventLoggerCache
+        this.eventLoggerHelper = eventLoggerHelper
+        this.executorService = executorService
+        this.isConfigureCalled = true
+
+        executorService.safeExecute {
+            registerToAppTransitions(appLifecycleObserver)
+            if (isTtlExpired()) {
+                sendAllEventsInStorage()
+            }
+        }
+    }
+
+    @SuppressWarnings(
+        "LongParameterList"
+    )
+    private fun logEvent(
+        eventType: EventType,
+        sourceName: String,
+        sourceVersion: String,
+        errorCode: String,
+        errorMessage: String,
+        info: Map<String, String>?
+    ) {
+        if (!isConfigureCalled ||
+            !eventLoggerHelper.isEventValid(sourceName, sourceVersion, errorCode, errorMessage)) {
+            log.warn("Event Logger is not configured or event contains an empty parameter, skip")
+            return
+        }
+
+        executorService.safeExecute {
+            val eventId = generateEventIdentifier(eventType.displayName, eventLoggerHelper.metadata.appVer,
+                sourceName, errorCode, errorMessage)
+            val storedEvent = eventsStorage.getEventById(eventId)
+            val eventToProcess = (storedEvent ?: eventLoggerHelper.buildEvent(eventType, sourceName, sourceVersion,
+                errorCode, errorMessage, info))
+                .incrementCount()
+
+            val isNewEvent = storedEvent == null
+            insertOrUpdateEvent(eventId, eventToProcess, isNewEvent)
+            sendEventIfNeeded(eventType, eventId, eventToProcess, isNewEvent)
+        }
+    }
+
+    private fun insertOrUpdateEvent(eventId: String, event: Event, isNewEvent: Boolean) {
+        if (isNewEvent) {
+            eventsStorage.insertEvent(eventId, event)
+        } else {
+            eventsStorage.updateEvent(eventId, event)
+        }
+    }
+
+    private fun sendEventIfNeeded(
+        eventType: EventType,
+        eventId: String,
+        event: Event,
+        isNewEvent: Boolean
+    ) {
+        // If full, send all of the events
+        if (eventsStorage.getCount() >= Config.MAX_EVENTS_COUNT) {
+            sendAllEventsInStorage(isNewEvent)
+            return
+        }
+
+        if (!isNewEvent) {
+            return
+        }
+
+        when (eventType) {
+            // Send the unique critical event immediately, and convert it to a warning type to prevent multiple
+            // alerts in server
+            EventType.CRITICAL -> sendEvents(
+                events = listOf(event),
+                onSuccess = {
+                    eventsStorage.updateEvent(eventId, event.setType(EventType.WARNING.displayName))
+                }
+            )
+            else -> { /* do nothing */ }
+        }
+    }
+
+    private fun registerToAppTransitions(observer: AppLifecycleObserver) {
+        observer.registerListener(object : LifecycleListener {
+            // When app transitioned to foreground, send all events if TTL expired
+            override fun becameForeground() {
+                executorService.safeExecute {
+                    if (isTtlExpired()) {
+                        sendAllEventsInStorage()
+                    }
+                }
+            }
+        })
+    }
+
+    private fun sendAllEventsInStorage(deleteOldEventsOnFailure: Boolean = false) {
+        val allEvents = eventsStorage.getAllEvents()
+        sendEvents(
+            events = allEvents.values.toList(),
+            onSuccess = {
+                eventLoggerCache.setTtlReferenceTime(System.currentTimeMillis())
+                this.eventsStorage.deleteEvents(allEvents.keys.toList())
+            },
+            onFailure = {
+                if (deleteOldEventsOnFailure) {
+                    eventsStorage.deleteOldEvents(Config.MAX_EVENTS_COUNT)
+                }
+            }
+        )
+    }
+
+    private fun sendEvents(events: List<Event>, onSuccess: (() -> Unit)? = null, onFailure: (() -> Unit)? = null) {
+        if (events.isEmpty()) return
+
+        eventsSender.pushEvents(
+            events = events,
+            onSuccess = onSuccess,
+            onFailure = onFailure
+        )
+    }
+
+    private fun isTtlExpired(): Boolean {
+        val currentTime = System.currentTimeMillis()
+        val referenceTime = eventLoggerCache.getTtlReferenceTime()
+
+        if (referenceTime == -1L) { // never pushed before
+            eventLoggerCache.setTtlReferenceTime(currentTime)
+            return false
+        }
+        return currentTime - referenceTime >= Config.TTL_EXPIRY_MILLIS
+    }
+
+    @SuppressWarnings(
+        "SwallowedException",
+        "TooGenericExceptionCaught"
+    )
+    /**
+     * ExecutorService extension for fail-safe execution of [command].
+     */
+    private fun <T> ExecutorService.safeExecute(command: () -> T?) {
+        try {
+            this.execute { command() }
+        } catch (e: Exception) {
+            log.debug("Failed to execute command")
+        }
+    }
+
+    internal object Config {
+        const val MAX_EVENTS_COUNT = 50
+        const val TTL_EXPIRY_MILLIS = 3600 * 1000 * 12 // 12 hours
+        const val EVENTS_STORAGE_FILENAME = "${BuildConfig.LIBRARY_PACKAGE_NAME}.eventlogger.events"
+        const val EVENT_LOGGER_GENERAL_CACHE_FILENAME = "${BuildConfig.LIBRARY_PACKAGE_NAME}.eventlogger.cache"
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCache.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCache.kt
new file mode 100644
index 0000000..6ed813f
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCache.kt
@@ -0,0 +1,41 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.SharedPreferences
+
+/**
+ * Interface to access general data or settings that the SDK needs to persist.
+ */
+internal interface EventLoggerCache {
+    /**
+     * Retrieves the reference time in checking TTL expiry, or -1 if not exists.
+     */
+    fun getTtlReferenceTime(): Long
+
+    /**
+     * Updates the reference time in checking TTL expiry. Call this whenever all events were successfully sent to
+     * server.
+     */
+    fun setTtlReferenceTime(pushedTimeMs: Long)
+}
+
+internal class SharedPreferencesEventLoggerCache(private val sharedPref: SharedPreferences) : EventLoggerCache {
+
+    override fun getTtlReferenceTime(): Long {
+        return try {
+            sharedPref.getLong(KEY_LAST_PUSHED_TIME, -1)
+        } catch (_: Exception) {
+            -1
+        }
+    }
+
+    override fun setTtlReferenceTime(pushedTimeMs: Long) {
+        with(sharedPref.edit()) {
+            putLong(KEY_LAST_PUSHED_TIME, pushedTimeMs)
+            apply()
+        }
+    }
+
+    companion object {
+        private const val KEY_LAST_PUSHED_TIME = "ttl_reference_time"
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelper.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelper.kt
new file mode 100644
index 0000000..2ab65b6
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelper.kt
@@ -0,0 +1,146 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.os.Build
+import android.provider.Settings
+import androidx.core.content.pm.PackageInfoCompat
+import com.rakuten.tech.mobile.sdkutils.StringExtension.sanitize
+import java.lang.ref.WeakReference
+
+/**
+ * Utility class for the event logger feature.
+ */
+@SuppressWarnings(
+    "SwallowedException"
+)
+internal class EventLoggerHelper(private val context: WeakReference<Context>) {
+
+    /**
+     * Information that is typically constant throughout the application lifecycle such as application and
+     * device information.
+     */
+    val metadata: Metadata = buildMetadata(context.get())
+
+    /**
+     * Returns true if all event parameters are non-empty, otherwise false.
+     */
+    fun isEventValid(
+        sourceName: String,
+        sourceVersion: String,
+        errorCode: String,
+        errorMessage: String
+    ): Boolean {
+        val isValidSourceInfo = sourceName.isNotEmpty() && sourceVersion.isNotEmpty()
+        val isValidErrorInfo = errorCode.isNotEmpty() && errorMessage.isNotEmpty()
+
+        return isValidSourceInfo && isValidErrorInfo
+    }
+
+    /**
+     * Attaches metadata to the event.
+     */
+    @SuppressWarnings("LongParameterList")
+    fun buildEvent(
+        type: EventType,
+        sourceName: String,
+        sourceVersion: String,
+        code: String,
+        message: String,
+        info: Map<String, String>? = null
+    ): Event {
+        return Event(
+            eventType = type.displayName,
+            appId = metadata.appId,
+            appName = metadata.appName,
+            appVersion = metadata.appVer,
+            osVersion = metadata.osVer,
+            deviceModel = metadata.deviceModel,
+            deviceBrand = metadata.deviceBrand,
+            deviceName = metadata.deviceName,
+            sdkName = sourceName.sanitize(MAX_EVENT_PARAM_LENGTH_DEFAULT),
+            sdkVersion = sourceVersion.sanitize(MAX_EVENT_PARAM_LENGTH_DEFAULT),
+            errorCode = code.sanitize(MAX_EVENT_PARAM_LENGTH_DEFAULT),
+            errorMessage = message.sanitize(MAX_EVENT_MESSAGE_LENGTH),
+            rmcSdks = metadata.rmcSdks,
+            info = info
+        )
+    }
+
+    @SuppressWarnings("LongMethod")
+    private fun buildMetadata(context: Context?): Metadata {
+        val packageInfo = if (context != null) {
+            try {
+                context.packageManager?.getPackageInfo(context.packageName, 0)
+            } catch (e: PackageManager.NameNotFoundException) {
+                null
+            }
+        } else {
+            null
+        }
+
+        return Metadata(
+            appId = context?.packageName.orEmpty(),
+            appName = context?.applicationInfo?.loadLabel(context.packageManager)?.toString().orEmpty(),
+            appVer = getAppVersion(packageInfo),
+            osVer = "Android ${Build.VERSION.RELEASE}",
+            deviceModel = Build.MODEL,
+            deviceBrand = Build.MANUFACTURER,
+            deviceName = Settings.Global.getString(context?.contentResolver, "device_name").orEmpty(),
+            rmcSdks = getRmcVersions()
+        )
+    }
+
+    private fun getAppVersion(packageInfo: PackageInfo?): String {
+        if (packageInfo != null) {
+            return "${packageInfo.versionName}.${PackageInfoCompat.getLongVersionCode(packageInfo)}"
+        }
+        return ""
+    }
+
+    private fun getRmcVersions(): Map<String, String>? {
+        val versionMap = mutableMapOf<String, String>()
+
+        listOf(
+            "rmc_inappmessaging"
+        ).forEach { sdkName ->
+            getVersionFromResource(context.get(), sdkName)?.let { version ->
+                versionMap[sdkName] = version
+            }
+        }
+        return versionMap.ifEmpty { null }
+    }
+
+    @SuppressWarnings(
+        "TooGenericExceptionCaught"
+    )
+    private fun getVersionFromResource(context: Context?, sdkName: String): String? {
+        return if (context != null) {
+            try {
+                context.getString(
+                    context.resources.getIdentifier(sdkName + "__version", "string", context.packageName))
+            } catch (e: Exception) {
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    internal data class Metadata(
+        val appId: String,
+        val appName: String,
+        val appVer: String,
+        val osVer: String,
+        val deviceModel: String,
+        val deviceBrand: String,
+        val deviceName: String,
+        val rmcSdks: Map<String, String>?
+    )
+
+    companion object {
+        private const val MAX_EVENT_PARAM_LENGTH_DEFAULT = 100
+        private const val MAX_EVENT_MESSAGE_LENGTH = 4000
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSender.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSender.kt
new file mode 100644
index 0000000..b081bfe
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSender.kt
@@ -0,0 +1,61 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.os.Handler
+import android.os.Looper
+import com.rakuten.tech.mobile.sdkutils.network.enqueueAndRetryOnNetworkError
+import okhttp3.ResponseBody
+import retrofit2.Call
+import retrofit2.http.Body
+import retrofit2.http.Header
+import retrofit2.http.POST
+
+@SuppressWarnings("kotlin:S6517")
+internal interface EventsSender {
+
+    /**
+     * Asynchronously sends [events] to the server.
+     */
+    fun pushEvents(events: List<Event>, onSuccess: (() -> Unit)? = null, onFailure: (() -> Unit)? = null)
+
+    companion object {
+        const val HEADER_CLIENT_API_KEY = "x-client-apikey"
+        const val MAX_REQUEST_RETRIES = 2
+        const val INITIAL_RETRY_DELAY_MILLIS = 1000L * 15
+    }
+}
+
+internal class RetrofitEventsSender(
+    private val retrofitApi: Api,
+    private val apiKey: String,
+    private val handler: Handler = Handler(Looper.getMainLooper())
+) : EventsSender {
+
+    @SuppressWarnings("kotlin:S6517")
+    internal interface Api {
+        @POST("external/logging/error")
+        fun sendEvents(
+            @Header(EventsSender.HEADER_CLIENT_API_KEY) apiKey: String,
+            @Body events: List<Event>
+        ): Call<ResponseBody?>
+    }
+
+    override fun pushEvents(events: List<Event>, onSuccess: (() -> Unit)?, onFailure: (() -> Unit)?) {
+        if (events.isEmpty())
+            return
+
+        val call = retrofitApi.sendEvents(apiKey, events)
+        call.enqueueAndRetryOnNetworkError(
+            maxRetries = EventsSender.MAX_REQUEST_RETRIES,
+            retryDelayMillis = EventsSender.INITIAL_RETRY_DELAY_MILLIS,
+            onSuccess = {
+                EventLogger.log.debug("Successfully pushed ${events.size} events")
+                onSuccess?.invoke()
+            },
+            onFailure = {
+                EventLogger.log.warn("Unable to push events: ${it.message}")
+                onFailure?.invoke()
+            },
+            handler = handler
+        )
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorage.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorage.kt
new file mode 100644
index 0000000..2b8e8bd
--- /dev/null
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorage.kt
@@ -0,0 +1,116 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.SharedPreferences
+import com.google.gson.Gson
+
+/**
+ * Interface to access events storage.
+ */
+internal interface EventsStorage {
+
+    /**
+     * Retrieves the events, or empty if the operation fails.
+     */
+    fun getAllEvents(): Map<String, Event>
+
+    /**
+     * Retrieves the event with matching [id].
+     */
+    fun getEventById(id: String): Event?
+
+    /**
+     * Retrieves the event count based on the number of existing keys in storage, or -1 if the operation fails.
+     */
+    fun getCount(): Int
+
+    /**
+     * Inserts the event with [id] as its key and [Event] in string format.
+     */
+    fun insertEvent(id: String, event: Event)
+
+    /**
+     * Updates the event with matching [id] key.
+     */
+    fun updateEvent(id: String, event: Event)
+
+    /**
+     * Deletes the events with the supplied [ids].
+     */
+    fun deleteEvents(ids: List<String>)
+
+    /**
+     * Deletes old events based on [Event.createdOn] and retains a maximum of [maxCapacity] events.
+     */
+    fun deleteOldEvents(maxCapacity: Int)
+}
+
+@SuppressWarnings(
+    "TooGenericExceptionCaught",
+    "SwallowedException"
+)
+internal class SharedPreferencesEventsStorage(private val sharedPref: SharedPreferences) : EventsStorage {
+
+    override fun getAllEvents(): Map<String, Event> {
+        val events = mutableMapOf<String, Event>()
+        try {
+            for (key in sharedPref.all.keys) {
+                val eventJson = getEventById(key) ?: continue
+                events[key] = eventJson
+            }
+        } catch (_: Exception) {
+            // return empty
+        }
+        return events
+    }
+
+    override fun getEventById(id: String): Event? {
+        return try {
+            val event = sharedPref.getString(id, null) ?: return null
+            Gson().fromJson(event, Event::class.java)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    override fun getCount(): Int {
+        return try {
+            sharedPref.all.keys.size
+        } catch (e: Exception) {
+            -1
+        }
+    }
+
+    override fun insertEvent(id: String, event: Event) {
+        insertOrUpdateEvent(id, event)
+    }
+
+    override fun updateEvent(id: String, event: Event) {
+        insertOrUpdateEvent(id, event)
+    }
+
+    override fun deleteEvents(ids: List<String>) {
+        with(sharedPref.edit()) {
+            ids.forEach {
+                remove(it)
+            }
+            apply()
+        }
+    }
+
+    override fun deleteOldEvents(maxCapacity: Int) {
+        if (getCount() <= maxCapacity) {
+            return
+        }
+
+        val sortedKeys = getAllEvents().entries.toList().sortedBy { (_, event) -> event.createdOn }.map { it.key }
+        val oldKeys = sortedKeys.take(0.coerceAtLeast(sortedKeys.size - maxCapacity))
+        deleteEvents(oldKeys)
+    }
+
+    private fun insertOrUpdateEvent(id: String, event: Event) {
+        with(sharedPref.edit()) {
+            putString(id, Gson().toJson(event))
+            apply()
+        }
+    }
+}
diff --git a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtils.kt b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtils.kt
index 344d341..d5a57e0 100644
--- a/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtils.kt
+++ b/sdk-utils/src/main/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtils.kt
@@ -1,8 +1,13 @@
 package com.rakuten.tech.mobile.sdkutils.network
 
+import android.os.Handler
 import okhttp3.OkHttpClient
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.Response
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
+import java.io.IOException
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 
@@ -29,3 +34,78 @@ fun Retrofit.Builder.build(
     .client(okHttpClient)
     .callbackExecutor(executor)
     .build()
+
+/**
+ * Retrofit [Call.enqueue] extension to perform retries after network failure.
+ *
+ * @param maxRetries the maximum retries after failure.
+ * @param retryDelayMillis the initial retry delay after failure.
+ * @param onRetry called when operation will be retried.
+ * @param onSuccess called when operation succeeds.
+ * @param onFailure called when operation fails even after retries.
+ * @param handler handler to use for delaying the retries.
+ */
+@SuppressWarnings(
+    "MagicNumber",
+    "LongParameterList"
+)
+fun <T> Call<T>.enqueueAndRetryOnNetworkError(
+    maxRetries: Int = 3,
+    retryDelayMillis: Long = 15 * 1000,
+    onRetry: (retryCount: Int, delayMillis: Long) -> Unit = { _, _ -> },
+    onSuccess: (response: Response<T>) -> Unit = {},
+    onFailure: (t: Throwable) -> Unit = {},
+    handler: Handler
+) {
+    fun <T> Call<T>.enqueueWithDelay(delayMillis: Long, callback: Callback<T>) {
+        handler.postDelayed(
+            { enqueue(callback) },
+            delayMillis
+        )
+    }
+
+    fun calculateExponentialDelay(retryCount: Int, initialDelayMillis: Long): Long {
+        return initialDelayMillis * (1L shl (retryCount - 1))
+    }
+
+    /**
+     * Returns true if within max retries and when [t] is an [IOException] which is typically thrown when there is
+     * network issue, such as device being offline.
+     */
+    fun shouldRetry(retryCount: Int, t: Throwable): Boolean {
+        if (retryCount < maxRetries &&
+            t is IOException
+        ) {
+            return true
+        }
+        return false
+    }
+
+    val retryCallback = object : Callback<T> {
+        private var retryCount = 0
+
+        override fun onResponse(call: Call<T>, response: Response<T>) {
+            if (response.isSuccessful) {
+                onSuccess(response)
+            } else {
+                // Server responded with errors
+                onFailure(Throwable("Code: ${response.code()}, Message: ${response.message()}"))
+            }
+        }
+
+        override fun onFailure(call: Call<T>, t: Throwable) {
+            // Check if should retry
+            if (shouldRetry(retryCount, t)) {
+                retryCount++
+                val delayMillis = calculateExponentialDelay(retryCount, retryDelayMillis)
+                onRetry(retryCount, delayMillis)
+                call.clone().enqueueWithDelay(delayMillis, this)
+            } else {
+                onFailure(t)
+            }
+        }
+    }
+
+    // Enqueue first call without delay
+    enqueueWithDelay(0, retryCallback)
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserverSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserverSpec.kt
new file mode 100644
index 0000000..8265661
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/AppLifecycleObserverSpec.kt
@@ -0,0 +1,64 @@
+package com.rakuten.tech.mobile.sdkutils
+
+import android.app.Activity
+import android.os.Bundle
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.*
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import java.lang.ref.WeakReference
+
+@RunWith(RobolectricTestRunner::class)
+@SuppressWarnings(
+    "EmptyFunctionBlock",
+    "TooGenericExceptionThrown"
+)
+class AppLifecycleObserverSpec {
+
+    private val activity = Robolectric.buildActivity(Activity::class.java)
+    private val observer = AppLifecycleObserver(WeakReference(activity.get()))
+
+    @Test
+    fun `should notify listener when transitioned from background to foreground`() {
+        val listenerSpy = spy(object : LifecycleListener {
+            override fun becameForeground() {}
+        })
+        observer.registerListener(listenerSpy)
+
+        // simulate put to background and go back to screen
+        activity.create().start().resume().pause().stop().resume()
+        verify(listenerSpy).becameForeground()
+    }
+
+    @Test
+    fun `should not notify listener if in foreground but not from background`() {
+        val listenerSpy = spy(object : LifecycleListener {
+            override fun becameForeground() {}
+        })
+        observer.registerListener(listenerSpy)
+
+        // simulate screen visited
+        activity.create().start().resume()
+        verify(listenerSpy, never()).becameForeground()
+
+        // simulate screen closed and new screen displayed
+        activity.create().start().resume().saveInstanceState(Bundle()).destroy()
+        val newActivity = Robolectric.buildActivity(Activity::class.java)
+        newActivity.create().start().resume()
+        verify(listenerSpy, never()).becameForeground()
+    }
+
+    @Test
+    fun `should not crash when listener throws exception`() {
+        val listenerSpy = spy(object : LifecycleListener {
+            override fun becameForeground() {
+                throw Exception("")
+            }
+        })
+        observer.registerListener(listenerSpy)
+
+        activity.create().start().resume().pause().stop().resume()
+        verify(listenerSpy).becameForeground()
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtensionSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtensionSpec.kt
index 420adf3..51b7f13 100644
--- a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtensionSpec.kt
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/StringExtensionSpec.kt
@@ -8,7 +8,9 @@ import com.rakuten.tech.mobile.sdkutils.StringExtension.getUTCDate
 import com.rakuten.tech.mobile.sdkutils.StringExtension.getUTF16ByteArray
 import com.rakuten.tech.mobile.sdkutils.StringExtension.getUTF16UrlEncoded
 import com.rakuten.tech.mobile.sdkutils.StringExtension.getUTF8UrlEncoded
+import com.rakuten.tech.mobile.sdkutils.StringExtension.sanitize
 import org.amshove.kluent.shouldBeEqualTo
+import org.amshove.kluent.shouldNotContain
 import org.junit.After
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -108,4 +110,23 @@ class StringExtensionSpec {
     fun `should get UTF-16 URL encoded value for empty string`() {
         "".getUTF16UrlEncoded() shouldBeEqualTo ""
     }
+
+    @Test
+    fun `should remove unwanted tabs from string`() {
+        try {
+            3 / 0 // Force an ArithmeticException
+        } catch (e: Exception) {
+            e.stackTraceToString().sanitize() shouldNotContain "\t"
+        }
+    }
+
+    @Test
+    fun `should trim leading and trailing spaces`() {
+        "  this is a test   ".sanitize() shouldBeEqualTo "this is a test"
+    }
+
+    @Test
+    fun `should not crash when maxLength is negative`() {
+        "this is a test".sanitize(-1) shouldBeEqualTo "this is a test"
+    }
 }
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCacheSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCacheSpec.kt
new file mode 100644
index 0000000..5a63fd2
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerCacheSpec.kt
@@ -0,0 +1,53 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.test.core.app.ApplicationProvider
+import com.nhaarman.mockitokotlin2.any
+import org.amshove.kluent.shouldBeEqualTo
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito
+import org.mockito.Mockito.`when`
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class EventLoggerCacheSpec {
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+    private val sharedPref = context.getSharedPreferences("test-cache", Context.MODE_PRIVATE)
+    private val eventLoggerCache = SharedPreferencesEventLoggerCache(sharedPref)
+
+    @Before
+    fun setup() {
+        clearSharedPrefs()
+    }
+
+    @Test
+    fun `should set TTL reference time`() {
+        eventLoggerCache.setTtlReferenceTime(1234)
+
+        eventLoggerCache.getTtlReferenceTime() shouldBeEqualTo 1234
+    }
+
+    @Test
+    fun `should return -1 when TTL reference time does not exist`() {
+        eventLoggerCache.getTtlReferenceTime() shouldBeEqualTo -1
+    }
+
+    @Test
+    fun `should return -1 when failed to retrieve TTL reference time`() {
+        val mockSharedPrefs = Mockito.mock(SharedPreferences::class.java)
+        `when`(mockSharedPrefs.getLong(any(), any()))
+            .thenThrow(ClassCastException())
+
+        SharedPreferencesEventLoggerCache(mockSharedPrefs).getTtlReferenceTime() shouldBeEqualTo -1
+    }
+
+    private fun clearSharedPrefs() {
+        with(sharedPref.edit()) {
+            clear()
+            commit()
+        }
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelperSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelperSpec.kt
new file mode 100644
index 0000000..3cb01b1
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerHelperSpec.kt
@@ -0,0 +1,164 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.content.res.Resources
+import android.os.Build
+import org.amshove.kluent.shouldBeEqualTo
+import org.amshove.kluent.shouldBeFalse
+import org.amshove.kluent.shouldBeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.*
+import org.robolectric.RobolectricTestRunner
+import java.lang.ref.WeakReference
+
+@RunWith(RobolectricTestRunner::class)
+class EventLoggerHelperSpec {
+
+    private val mockContext = mock(Context::class.java)
+    private val mockPm = mock(PackageManager::class.java)
+    private val eventLoggerHelper: EventLoggerHelper
+
+    init {
+        val mockAppInfo = mock(ApplicationInfo::class.java)
+        val mockPackageInfo = mock(PackageInfo::class.java)
+
+        `when`(mockContext.packageName)
+            .thenReturn("com.sdkutils")
+        `when`(mockContext.packageManager)
+            .thenReturn(mockPm)
+        `when`(mockPm.getPackageInfo(mockContext.packageName, 0))
+            .thenReturn(mockPackageInfo)
+        `when`(mockContext.applicationInfo)
+            .thenReturn(mockAppInfo)
+        `when`(mockAppInfo.loadLabel(mockPm))
+            .thenReturn("sdk utils sample app")
+        `when`(mockContext.resources)
+            .thenReturn(mock(Resources::class.java))
+        `when`(mockContext.getString(anyInt()))
+            .thenReturn("2.0.0")
+        mockPackageInfo.versionName = "1.0.0"
+        mockPackageInfo.versionCode = 1
+
+        eventLoggerHelper = EventLoggerHelper(WeakReference(mockContext))
+    }
+
+    @Test
+    fun `should return metadata`() {
+        eventLoggerHelper.metadata shouldBeEqualTo
+            EventLoggerHelper.Metadata(
+                "com.sdkutils",
+                "sdk utils sample app",
+                "1.0.0.1",
+                "Android ${Build.VERSION.RELEASE}",
+                Build.MODEL,
+                Build.MANUFACTURER,
+                "",
+                mapOf("rmc_inappmessaging" to "2.0.0")
+            )
+    }
+
+    @Test
+    fun `should build critical event with metadata`() {
+        val event = eventLoggerHelper.buildEvent(
+            EventType.CRITICAL,
+            "push",
+            "3.0.0",
+            "400",
+            "invalid key",
+        )
+        event.run {
+            eventType shouldBeEqualTo EventType.CRITICAL.displayName
+            appId shouldBeEqualTo "com.sdkutils"
+            appName shouldBeEqualTo "sdk utils sample app"
+            appVersion shouldBeEqualTo "1.0.0.1"
+            rmcSdks shouldBeEqualTo mapOf("rmc_inappmessaging" to "2.0.0")
+            osVersion shouldBeEqualTo "Android ${Build.VERSION.RELEASE}"
+            deviceModel shouldBeEqualTo Build.MODEL
+            deviceBrand shouldBeEqualTo Build.MANUFACTURER
+        }
+    }
+
+    @Test
+    fun `should build warning event with metadata`() {
+        val event = eventLoggerHelper.buildEvent(
+            EventType.WARNING,
+            "push",
+            "3.0.0",
+            "400",
+            "invalid key",
+        )
+        event.run {
+            eventType shouldBeEqualTo EventType.WARNING.displayName
+            appId shouldBeEqualTo "com.sdkutils"
+            appName shouldBeEqualTo "sdk utils sample app"
+            appVersion shouldBeEqualTo "1.0.0.1"
+            rmcSdks shouldBeEqualTo mapOf("rmc_inappmessaging" to "2.0.0")
+            osVersion shouldBeEqualTo "Android ${Build.VERSION.RELEASE}"
+            deviceModel shouldBeEqualTo Build.MODEL
+            deviceBrand shouldBeEqualTo Build.MANUFACTURER
+        }
+    }
+
+    @Test
+    fun `should set appVer to empty if exception is encountered`() {
+        `when`(mockPm.getPackageInfo(mockContext.packageName, 0))
+            .thenThrow(PackageManager.NameNotFoundException())
+
+        val eventLoggerHelper = EventLoggerHelper(WeakReference(mockContext))
+        val event = eventLoggerHelper.buildEvent(
+            EventType.CRITICAL,
+            "push",
+            "3.0.0",
+            "400",
+            "invalid key",
+        )
+
+        event.appVersion shouldBeEqualTo ""
+    }
+
+    @Test
+    @SuppressWarnings("TooGenericExceptionThrown")
+    fun `should set rmcSdks to null if not exists`() {
+        `when`(mockContext.getString(anyInt()))
+            .thenAnswer { throw Exception() }
+
+        val eventLoggerHelper = EventLoggerHelper(WeakReference(mockContext))
+        val event = eventLoggerHelper.buildEvent(
+            EventType.CRITICAL,
+            "push",
+            "3.0.0",
+            "400",
+            "invalid key",
+        )
+
+        event.rmcSdks shouldBeEqualTo null
+    }
+
+    @Test
+    fun `should return false when source info is invalid`() {
+        eventLoggerHelper.isEventValid(sourceName = "", sourceVersion = "test", "test", "test")
+            .shouldBeFalse()
+
+        eventLoggerHelper.isEventValid(sourceName = "test", sourceVersion = "", "test", "test")
+            .shouldBeFalse()
+    }
+
+    @Test
+    fun `should return false when error info is invalid`() {
+        eventLoggerHelper.isEventValid("test", "test", errorCode = "", errorMessage = "test")
+            .shouldBeFalse()
+
+        eventLoggerHelper.isEventValid("test", "", errorCode = "test", errorMessage = "")
+            .shouldBeFalse()
+    }
+
+    @Test
+    fun `should return true for valid event details`() {
+        eventLoggerHelper.isEventValid("test", "test", "test", "test")
+            .shouldBeTrue()
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerSpec.kt
new file mode 100644
index 0000000..0b2bbd1
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerSpec.kt
@@ -0,0 +1,304 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.app.Activity
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.test.core.app.ApplicationProvider
+import com.google.common.util.concurrent.MoreExecutors
+import com.nhaarman.mockitokotlin2.argumentCaptor
+import com.rakuten.tech.mobile.sdkutils.AppLifecycleObserver
+import org.junit.Before
+import org.junit.FixMethodOrder
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.MethodSorters
+import org.mockito.Mockito.*
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import java.lang.ref.WeakReference
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.RejectedExecutionException
+import java.util.concurrent.TimeUnit
+
+@RunWith(RobolectricTestRunner::class)
+@SuppressWarnings("UnnecessaryAbstractClass")
+abstract class EventLoggerSpec {
+
+    internal val mockContext = mock(Context::class.java)
+    internal val mockEventsSender = mock(EventsSender::class.java)
+    internal val mockEventsStorage = mock(EventsStorage::class.java)
+    internal val mockEventLoggerCache = mock(EventLoggerCache::class.java)
+    internal val eventLoggerHelper = EventLoggerHelper(WeakReference(ApplicationProvider.getApplicationContext()))
+    internal val lifecycleListener = AppLifecycleObserver(WeakReference(ApplicationProvider.getApplicationContext()))
+    internal val tasksQueue = MoreExecutors.newDirectExecutorService()
+
+    init {
+        `when`(mockContext.getSharedPreferences(anyString(), anyInt()))
+            .thenReturn(mock(SharedPreferences::class.java))
+        `when`(mockContext.applicationContext)
+            .thenReturn(mockContext)
+    }
+
+    fun configureWithMocks() {
+        EventLogger.initialize(
+            mockEventsSender,
+            mockEventsStorage,
+            mockEventLoggerCache,
+            eventLoggerHelper,
+            lifecycleListener,
+            tasksQueue
+        )
+    }
+}
+
+class GeneralSpec : EventLoggerSpec() {
+
+    @Before
+    fun setup() {
+        configureWithMocks()
+    }
+
+    @Test
+    fun `should not crash when executorService fails to execute command`() {
+        val mockTasksQueue = mock(ExecutorService::class.java)
+        `when`(mockTasksQueue.execute(any()))
+            .thenThrow(RejectedExecutionException(""))
+
+        EventLogger.initialize(
+            mockEventsSender,
+            mockEventsStorage,
+            mockEventLoggerCache,
+            eventLoggerHelper,
+            lifecycleListener,
+            mockTasksQueue
+        )
+    }
+
+    @Test
+    fun `should not process event with missing details`() {
+        EventLogger.sendCriticalEvent(sourceName = "", sourceVersion = "test", "test", "test")
+
+        verify(mockEventsStorage, never()).getEventById(anyString())
+    }
+
+    @Test
+    fun `should send events if storage is full`() {
+        val testEvent = EventLoggerTestUtil.generateRandomEvent()
+        `when`(mockEventsStorage.getCount())
+            .thenReturn(EventLogger.Config.MAX_EVENTS_COUNT) // simulate storage full
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf("id1" to testEvent))
+        `when`(mockEventsStorage.getEventById(anyString()))
+            .thenReturn(testEvent)
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(System.currentTimeMillis())
+
+        EventLogger.sendCriticalEvent(
+            "test",
+            "test",
+            "test",
+            "test"
+        )
+
+        verify(mockEventsSender).pushEvents(anyList(), any(), any())
+    }
+
+    @SuppressWarnings("LongMethod")
+    @Test
+    fun `should delete old event if storage is full and sending failed`() {
+        `when`(mockEventsStorage.getCount())
+            .thenReturn(EventLogger.Config.MAX_EVENTS_COUNT) // simulate storage full
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf("id1" to EventLoggerTestUtil.generateRandomEvent()))
+        `when`(mockEventsStorage.getEventById(anyString()))
+            .thenReturn(null)
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(System.currentTimeMillis())
+
+        EventLogger.sendWarningEvent(
+            "test",
+            "test",
+            "test",
+            "test"
+        )
+
+        val captor = argumentCaptor<() -> Unit>()
+        verify(mockEventsSender).pushEvents(anyList(), any(), captor.capture())
+        captor.firstValue.invoke()
+        verify(mockEventsStorage).deleteOldEvents(anyInt())
+    }
+}
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@SuppressWarnings("LongMethod")
+class ConfigureSpec : EventLoggerSpec() {
+
+    @Test
+    fun `0 - should ignore calls if configure not called`() {
+        val spy = spy(EventLogger)
+        spy.sendWarningEvent(
+            "test",
+            "test",
+            "test",
+            "test"
+        )
+
+        verify(spy, never()).initialize(
+            any() ?: mockEventsSender,
+            any() ?: mockEventsStorage,
+            any() ?: mockEventLoggerCache,
+            any() ?: eventLoggerHelper,
+            any() ?: lifecycleListener,
+            any() ?: tasksQueue
+        )
+    }
+
+    @Test
+    fun `1 - should configure only once`() {
+        EventLogger.configure(mockContext, "", "")
+        EventLogger.configure(mockContext, "https://test", "abcd")
+        EventLogger.configure(mockContext, "https://test2", "wxyz")
+
+        verify(mockContext, times(1)).getSharedPreferences(
+            EventLogger.Config.EVENTS_STORAGE_FILENAME,
+            Context.MODE_PRIVATE
+        )
+        verify(mockContext, times(1)).getSharedPreferences(
+            EventLogger.Config.EVENT_LOGGER_GENERAL_CACHE_FILENAME,
+            Context.MODE_PRIVATE
+        )
+    }
+
+    @Test
+    fun `should send events when TTL expired and delete from storage afterwards - configure`() {
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(TimeUnit.MILLISECONDS.toDays(30)) // simulate expiry
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf("id1" to EventLoggerTestUtil.generateRandomEvent()))
+
+        configureWithMocks()
+
+        val captor = argumentCaptor<() -> Unit>()
+        verify(mockEventsSender).pushEvents(
+            anyList(),
+            captor.capture(),
+            any()
+        )
+        captor.firstValue.invoke()
+        verify(mockEventsStorage).deleteEvents(anyList())
+    }
+
+    @Test
+    fun `should send events when TTL expired and delete from storage afterwards - becameForeground`() {
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(TimeUnit.MILLISECONDS.toDays(30)) // simulate expiry
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf("id1" to EventLoggerTestUtil.generateRandomEvent()))
+
+        val activity = Robolectric.buildActivity(Activity::class.java)
+        val observer = AppLifecycleObserver(WeakReference(activity.get()))
+        EventLogger.initialize(
+            mockEventsSender,
+            mockEventsStorage,
+            mockEventLoggerCache,
+            eventLoggerHelper,
+            observer,
+            tasksQueue
+        )
+
+        activity.create().start().resume().pause().stop().resume() // simulate transition
+        val captor = argumentCaptor<() -> Unit>()
+        verify(mockEventsSender, atLeastOnce()).pushEvents(
+            anyList(),
+            captor.capture(),
+            any()
+        )
+        captor.firstValue.invoke()
+        verify(mockEventsStorage).deleteEvents(anyList())
+    }
+
+    @Test
+    fun `should not process if storage is empty`() {
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf())
+
+        configureWithMocks()
+
+        verify(mockEventsSender, never()).pushEvents(anyList(), any(), any())
+    }
+
+    @Test
+    fun `should not process if TTL not yet expired`() {
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(-1)
+
+        configureWithMocks()
+
+        verify(mockEventsSender, never()).pushEvents(anyList(), any(), any())
+    }
+}
+
+@SuppressWarnings("LongMethod")
+class SendCriticalSpec : EventLoggerSpec() {
+
+    @Before
+    fun setup() {
+        configureWithMocks()
+    }
+
+    @Test
+    @SuppressWarnings("LongMethod")
+    fun `should send critical event immediately and update type`() {
+        `when`(mockEventsStorage.getCount())
+            .thenReturn(1)
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf())
+        `when`(mockEventsStorage.getEventById(anyString()))
+            .thenReturn(null)
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(System.currentTimeMillis())
+
+        EventLogger.sendCriticalEvent(
+            "test",
+            "test",
+            "test",
+            "test"
+        )
+
+        val captor = argumentCaptor<() -> Unit>()
+        verify(mockEventsSender).pushEvents(anyList(), captor.capture(), any())
+
+        captor.firstValue.invoke()
+        verify(mockEventsStorage).updateEvent(anyString(), com.nhaarman.mockitokotlin2.any())
+    }
+}
+
+class SendWarningSpec : EventLoggerSpec() {
+
+    @Before
+    fun setup() {
+        configureWithMocks()
+    }
+
+    @Test
+    fun `should do nothing if warning event is received`() {
+        val testEvent = EventLoggerTestUtil.generateRandomEvent()
+        `when`(mockEventsStorage.getCount())
+            .thenReturn(1)
+        `when`(mockEventsStorage.getAllEvents())
+            .thenReturn(mapOf("id1" to testEvent))
+        `when`(mockEventsStorage.getEventById(anyString()))
+            .thenReturn(testEvent)
+        `when`(mockEventLoggerCache.getTtlReferenceTime())
+            .thenReturn(System.currentTimeMillis())
+
+        EventLogger.sendWarningEvent(
+            "inappmessaging",
+            "1.0.0",
+            "500",
+            "server error"
+        )
+
+        verify(mockEventsSender, never()).pushEvents(anyList(), any(), any())
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerTestUtil.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerTestUtil.kt
new file mode 100644
index 0000000..825a590
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventLoggerTestUtil.kt
@@ -0,0 +1,23 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import java.lang.ref.WeakReference
+import kotlin.random.Random
+
+internal object EventLoggerTestUtil {
+
+    private val context: Context = ApplicationProvider.getApplicationContext()
+
+    fun generateRandomEvent(): Event {
+        val randomText = System.currentTimeMillis().toString()
+        return EventLoggerHelper(WeakReference(context))
+            .buildEvent(
+                EventType.values()[Random.nextInt(EventType.values().size)],
+                randomText,
+                randomText,
+                randomText,
+                randomText
+            )
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventSpec.kt
new file mode 100644
index 0000000..9bacf01
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventSpec.kt
@@ -0,0 +1,160 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import com.google.gson.Gson
+import com.rakuten.tech.mobile.sdkutils.StringExtension
+import com.rakuten.tech.mobile.sdkutils.StringExtension.getMD5HashData
+import org.amshove.kluent.*
+import org.junit.After
+import org.junit.Test
+
+class EventSpec {
+
+    @After
+    fun tearDown() {
+        StringExtension.stringForTest = null
+    }
+
+    private val testEvent = Event(
+        "0",
+        "sdkutils.sample",
+        "sdkutils.sample",
+        "1.0.0",
+        "Android 10",
+        "Galaxy",
+        "Samsung",
+        "S2",
+        "inappmessaging",
+        "1.0.0",
+        "500",
+        "server error",
+        mapOf("rmc_push" to "1.0.0"),
+        mapOf("file_name" to "MyFile.kt"),
+        2
+    )
+
+    @Test
+    @SuppressWarnings("LongMethod")
+    fun `should correctly map mutable and automatic fields`() {
+        val testEvent = testEvent.copy(
+            occurrenceCount = 5
+        )
+
+        testEvent.run {
+            eventType shouldBeEqualTo "0"
+            appId shouldBeEqualTo "sdkutils.sample"
+            appName shouldBeEqualTo "sdkutils.sample"
+            appVersion shouldBeEqualTo "1.0.0"
+            osVersion shouldBeEqualTo "Android 10"
+            deviceModel shouldBeEqualTo "Galaxy"
+            deviceBrand shouldBeEqualTo "Samsung"
+            deviceName shouldBeEqualTo "S2"
+            sdkName shouldBeEqualTo "inappmessaging"
+            sdkVersion shouldBeEqualTo "1.0.0"
+            errorCode shouldBeEqualTo "500"
+            errorMessage shouldBeEqualTo "server error"
+            rmcSdks shouldBeEqualTo mapOf("rmc_push" to "1.0.0")
+            info shouldBeEqualTo mapOf("file_name" to "MyFile.kt")
+            occurrenceCount shouldBeEqualTo 5
+            eventVersion shouldBeEqualTo "1.0"
+            platform shouldBeEqualTo "Android"
+        }
+    }
+
+    @Test
+    @SuppressWarnings("LongMethod")
+    fun `should serialize Event with correct json field names`() {
+        Gson().toJson(testEvent) shouldContainAll listOf(
+            "eventVersion",
+            "eventType",
+            "appId",
+            "appName",
+            "appVersion",
+            "platform",
+            "osVersion",
+            "deviceModel",
+            "deviceBrand",
+            "deviceName",
+            "sdkName",
+            "sdkVersion",
+            "errorCode",
+            "errorMessage",
+            "rmcSdks",
+            "info",
+            "occurrenceCount",
+            "firstOccurrenceOn"
+        )
+    }
+
+    @Test
+    fun `should not serialize null values`() {
+        val testEvent = testEvent.copy(
+            rmcSdks = null,
+            info = null
+        )
+        Gson().toJson(testEvent) shouldNotContainAll listOf(
+            "rmcSdks",
+            "info"
+        )
+    }
+
+    @Test
+    fun `should automatically set platform value`() {
+        testEvent.platform shouldBe "Android"
+    }
+
+    @Test
+    fun `should automatically set eventVer value`() {
+        testEvent.eventVersion shouldNotBe null
+    }
+
+    @Test
+    fun `Event occurrenceCount should be mutable`() {
+        val testEvent = testEvent.copy(
+            occurrenceCount = 5
+        )
+        testEvent.occurrenceCount shouldBeEqualTo 5
+    }
+
+    @Test
+    fun `should set correct critical event type from enum`() {
+        EventType.CRITICAL.displayName shouldBeEqualTo "0"
+    }
+
+    @Test
+    fun `should set correct warning event type from enum`() {
+        EventType.WARNING.displayName shouldBeEqualTo "1"
+    }
+
+    @Test
+    fun `should update type`() {
+        val testEvent = testEvent.copy(
+            eventType = EventType.CRITICAL.displayName
+        )
+
+        testEvent.setType(EventType.WARNING.displayName)
+        testEvent.eventType shouldBeEqualTo EventType.WARNING.displayName
+    }
+
+    @Test
+    fun `should return hash data`() {
+        generateEventIdentifier(
+            "a",
+            "b",
+            "c",
+            "d",
+            "e"
+        ) shouldBeEqualTo "abcde".getMD5HashData()
+    }
+
+    @Test
+    fun `should return original data when hashing fails`() {
+        StringExtension.stringForTest = "anyAlgorithm"
+        generateEventIdentifier(
+            "a",
+            "b",
+            "c",
+            "d",
+            "e"
+        ) shouldBeEqualTo "abcde"
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSenderSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSenderSpec.kt
new file mode 100644
index 0000000..3cac3f2
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsSenderSpec.kt
@@ -0,0 +1,117 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.os.Handler
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.never
+import com.nhaarman.mockitokotlin2.verify
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.amshove.kluent.shouldBeEqualTo
+import org.amshove.kluent.shouldContainAll
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.*
+import org.robolectric.RobolectricTestRunner
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+import java.net.HttpURLConnection
+import java.time.Duration
+
+@RunWith(RobolectricTestRunner::class)
+class EventsSenderSpec {
+
+    private val mockHandler: Handler = mock(Handler::class.java)
+    private val mockWebServer = MockWebServer()
+    private val retrofitApi = Retrofit
+        .Builder()
+        .baseUrl(mockWebServer.url("").toString())
+        .addConverterFactory(GsonConverterFactory.create())
+        .build()
+        .create(RetrofitEventsSender.Api::class.java)
+    private val eventsSender = RetrofitEventsSender(retrofitApi, "mockApiKey", mockHandler)
+
+    @Before
+    fun setup() {
+        `when`(mockHandler.postDelayed(any(Runnable::class.java), anyLong()))
+            .thenAnswer {
+                (it.arguments[0] as Runnable).run()
+                true
+            }
+    }
+
+    @Test
+    fun `should do nothing if events list is empty`() {
+        val callback: () -> Unit = mock()
+        eventsSender.pushEvents(
+            listOf(),
+            callback
+        )
+
+        verify(callback, never()).invoke()
+    }
+
+    @Test
+    @SuppressWarnings("LongMethod")
+    fun `should send json request based on backend contract`() {
+        mockWebServer.enqueue(MockResponse()
+            .setResponseCode(HttpURLConnection.HTTP_OK))
+
+        eventsSender.pushEvents(
+            listOf(EventLoggerTestUtil.generateRandomEvent())
+        )
+
+        val request = mockWebServer.takeRequest()
+        request.getHeader(EventsSender.HEADER_CLIENT_API_KEY) shouldBeEqualTo "mockApiKey"
+        val requestBody = request.body.readUtf8()
+        requestBody shouldContainAll listOf(
+            "eventVersion",
+            "eventType",
+            "appId",
+            "appName",
+            "appVersion",
+            "platform",
+            "osVersion",
+            "deviceModel",
+            "deviceBrand",
+            "deviceName",
+            "sdkName",
+            "sdkVersion",
+            "errorCode",
+            "errorMessage",
+            "occurrenceCount"
+        )
+    }
+
+    @Test
+    fun `should invoke success callback if server responded with HTTP OK`() {
+        mockWebServer.enqueue(
+            MockResponse()
+                .setResponseCode(HttpURLConnection.HTTP_OK)
+        )
+
+        val callback: () -> Unit = mock()
+        eventsSender.pushEvents(
+            listOf(EventLoggerTestUtil.generateRandomEvent()),
+            callback,
+            null
+        )
+
+        verify(callback, timeout(Duration.ofMillis(500))).invoke()
+    }
+
+    @Test
+    fun `should invoke failure callback if server responded with HTTP failure`() {
+        mockWebServer.enqueue(MockResponse()
+            .setResponseCode(HttpURLConnection.HTTP_INTERNAL_ERROR))
+
+        val callback: () -> Unit = mock()
+        eventsSender.pushEvents(
+            listOf(EventLoggerTestUtil.generateRandomEvent()),
+            null,
+            callback
+        )
+
+        verify(callback, timeout(Duration.ofMillis(500))).invoke()
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorageSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorageSpec.kt
new file mode 100644
index 0000000..1fbdc25
--- /dev/null
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/eventlogger/EventsStorageSpec.kt
@@ -0,0 +1,146 @@
+package com.rakuten.tech.mobile.sdkutils.eventlogger
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.test.core.app.ApplicationProvider
+import org.amshove.kluent.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.`when`
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class EventsStorageSpec {
+
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+    private val sharedPref = context.getSharedPreferences("test-shared-prefs", Context.MODE_PRIVATE)
+    private val eventsStorage = SharedPreferencesEventsStorage(sharedPref)
+
+    @Before
+    fun setup() {
+        clearSharedPrefs()
+    }
+
+    @Test
+    fun `getAllEvents should return all events`() {
+        eventsStorage.insertEvent("id1", EventLoggerTestUtil.generateRandomEvent())
+        eventsStorage.insertEvent("id2", EventLoggerTestUtil.generateRandomEvent())
+
+        eventsStorage.getAllEvents().size shouldBeEqualTo 2
+    }
+
+    @Test
+    fun `getAllEvents should not crash if exception occurs`() {
+        val mockSharedPrefs = mock(SharedPreferences::class.java)
+        `when`(mockSharedPrefs.all)
+            .thenThrow(NullPointerException())
+
+        SharedPreferencesEventsStorage(mockSharedPrefs).getAllEvents().shouldBeEmpty()
+    }
+
+    @Test
+    fun `getEventById should return correct event`() {
+        val event = EventLoggerTestUtil.generateRandomEvent()
+        eventsStorage.insertEvent("id1", event)
+
+        eventsStorage.getEventById("id1") shouldBeEqualTo event
+    }
+
+    @Test
+    fun `getEventById should return null event if not exists`() {
+        eventsStorage.getEventById("some-random-id") shouldBeEqualTo null
+    }
+
+    @Test
+    fun `getEventById should not crash if exception occurs`() {
+        val mockSharedPrefs = mock(SharedPreferences::class.java)
+        `when`(mockSharedPrefs.getString("test-id", null))
+            .thenThrow(ClassCastException())
+
+        SharedPreferencesEventsStorage(mockSharedPrefs).getEventById("test-id") shouldBeEqualTo null
+    }
+
+    @Test
+    fun `getCount should return correct count`() {
+        eventsStorage.insertEvent("id1", EventLoggerTestUtil.generateRandomEvent())
+        eventsStorage.insertEvent("id2", EventLoggerTestUtil.generateRandomEvent())
+
+        eventsStorage.getCount() shouldBeEqualTo 2
+    }
+
+    @Test
+    fun `getCount should not crash if exception occurs`() {
+        val mockSharedPrefs = mock(SharedPreferences::class.java)
+        `when`(mockSharedPrefs.all)
+            .thenThrow(NullPointerException())
+
+        SharedPreferencesEventsStorage(mockSharedPrefs).getCount() shouldBeEqualTo -1
+    }
+
+    @Test
+    fun `should insert event`() {
+        val event = EventLoggerTestUtil.generateRandomEvent()
+        eventsStorage.insertEvent("id1", event)
+        eventsStorage.getEventById("id1") shouldNotBeEqualTo null
+    }
+
+    @Test
+    fun `should update event`() {
+        val origEvent = EventLoggerTestUtil.generateRandomEvent()
+        eventsStorage.insertEvent("id1", origEvent)
+
+        val updatedEvent = origEvent
+            .incrementCount()
+            .incrementCount()
+            .incrementCount()
+        eventsStorage.updateEvent("id1", updatedEvent)
+
+        eventsStorage.getEventById("id1")?.occurrenceCount shouldBeEqualTo 3
+    }
+
+    @Test
+    fun `should delete events`() {
+        val event1 = EventLoggerTestUtil.generateRandomEvent()
+        val event2 = EventLoggerTestUtil.generateRandomEvent()
+        eventsStorage.insertEvent("id1", event1)
+        eventsStorage.insertEvent("id2", event2)
+
+        eventsStorage.deleteEvents(listOf("id1", "id2"))
+
+        eventsStorage.getCount() shouldBeEqualTo 0
+    }
+
+    @Test
+    fun `deleteOldEvents should delete old events based on max capacity`() {
+        val event1 = EventLoggerTestUtil.generateRandomEvent()
+        val event2 = EventLoggerTestUtil.generateRandomEvent()
+        eventsStorage.insertEvent(event1.generateEventIdentifier(), event1)
+        eventsStorage.insertEvent(event2.generateEventIdentifier(), event2)
+
+        eventsStorage.deleteOldEvents(1)
+
+        eventsStorage.getCount() shouldBeEqualTo 1
+        val events = eventsStorage.getAllEvents().values
+        events shouldContain event2
+        events shouldNotContain event1
+    }
+
+    @Test
+    fun `deleteOldEvents should not delete any event if within max capacity`() {
+        eventsStorage.insertEvent("id1", EventLoggerTestUtil.generateRandomEvent())
+        eventsStorage.insertEvent("id2", EventLoggerTestUtil.generateRandomEvent())
+
+        eventsStorage.deleteOldEvents(5)
+
+        eventsStorage.getCount() shouldBeEqualTo 2
+    }
+
+    private fun clearSharedPrefs() {
+        with(sharedPref.edit()) {
+            clear()
+            commit()
+        }
+    }
+}
diff --git a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtilsSpec.kt b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtilsSpec.kt
index d83f8a7..1955bdf 100644
--- a/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtilsSpec.kt
+++ b/sdk-utils/src/test/kotlin/com/rakuten/tech/mobile/sdkutils/network/RetrofitUtilsSpec.kt
@@ -1,14 +1,26 @@
 package com.rakuten.tech.mobile.sdkutils.network
 
+import android.os.Handler
 import okhttp3.OkHttpClient
+import okhttp3.ResponseBody
 import org.amshove.kluent.shouldBeEqualTo
 import org.amshove.kluent.shouldBeInstanceOf
 import org.amshove.kluent.shouldContain
 import org.junit.Test
+import org.mockito.Mockito.*
+import retrofit2.Call
+import retrofit2.Callback
+import retrofit2.Response
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.Before
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.io.IOException
+import java.time.Duration
 
 class RetrofitUtilsSpec {
     private val baseUrl = "www.example.com"
@@ -35,3 +47,83 @@ class RetrofitUtilsSpec {
         retrofit.callbackExecutor() shouldBeEqualTo executor
     }
 }
+
+@RunWith(RobolectricTestRunner::class)
+class RetrofitUtilsEnqueueAndRetrySpec {
+
+    private val mockHandler: Handler = mock(Handler::class.java)
+    private val call = mock(Call::class.java) as Call<ResponseBody?>
+
+    @Before
+    fun setup() {
+        `when`(mockHandler.postDelayed(any(Runnable::class.java), anyLong()))
+            .thenAnswer {
+                (it.arguments[0] as Runnable).run()
+                true
+            }
+    }
+
+    @Test
+    fun `should invoke success callback if successful`() {
+        `when`(call.enqueue(any()))
+            .thenAnswer {
+                (it.arguments[0] as Callback<ResponseBody?>)
+                    .onResponse(call, Response.success(null))
+                null
+            }
+
+        val callback: (Response<ResponseBody?>) -> Unit = mock()
+        call.enqueueAndRetryOnNetworkError(
+            onSuccess = callback,
+            handler = mockHandler
+        )
+
+        verify(callback, timeout(Duration.ofMillis(500))).invoke(
+            com.nhaarman.mockitokotlin2.any()
+        )
+    }
+
+    @Test
+    fun `should invoke failure callback`() {
+        `when`(call.enqueue(any()))
+            .thenAnswer {
+                (it.arguments[0] as Callback<ResponseBody?>)
+                    .onFailure(call, Throwable(""))
+                null
+            }
+
+        val callback: (Throwable) -> Unit = mock()
+        call.enqueueAndRetryOnNetworkError(
+            onFailure = callback,
+            handler = mockHandler
+        )
+        verify(callback, timeout(Duration.ofMillis(500)))
+            .invoke(any(Throwable::class.java) ?: Throwable())
+    }
+
+    @SuppressWarnings("LongMethod")
+    @Test
+    fun `should retry on IOException and invoke failure callback`() {
+        `when`(call.clone())
+            .thenReturn(call)
+        `when`(call.enqueue(any()))
+            .thenAnswer {
+                (it.arguments[0] as Callback<ResponseBody?>)
+                    .onFailure(call, IOException(""))
+                null
+            }
+            .thenAnswer {
+                (it.arguments[0] as Callback<ResponseBody?>)
+                    .onFailure(call, Throwable(""))
+                null
+            }
+
+        val callback: (Throwable) -> Unit = mock()
+        call.enqueueAndRetryOnNetworkError(
+            onFailure = callback,
+            handler = mockHandler
+        )
+        verify(callback, timeout(Duration.ofMillis(500)))
+            .invoke(any(Throwable::class.java) ?: Throwable())
+    }
+}