diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000000..ba41180982
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+*       @microsoft/appcenter-fte
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e5aef28f3d..2a9a5d4aea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,17 @@
 # App Center SDK for Android Change Log
 
+## Version 5.0.0
+
+### AppCenter
+
+* **[Fix]** Fix ignoring maximum storage size limit in case logs contain large payloads.
+
+### App Center Distribute
+
+* **[Feature]** Add requesting notifications permission for Android 13 (notifications are used to inform about downloading/installing status if an application is in background)
+
+ ___
+
 ## Version 4.4.5
 
 ### App Center
diff --git a/cgmanifest.json b/cgmanifest.json
index f6b9d59daf..ecebf1b32f 100644
--- a/cgmanifest.json
+++ b/cgmanifest.json
@@ -1,123 +1,124 @@
 {
-    "Registrations": [
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "gradle",
-                    "groupId": "com.android.tools.build",
-                    "version": "3.3.2"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "gradle-bintray-plugin",
-                    "groupId": "com.jfrog.bintray.gradle",
-                    "version": "1.8.0"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "android-maven-gradle-plugin",
-                    "groupId": "com.github.dcendents",
-                    "version": "2.0"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "coveralls-gradle-plugin",
-                    "groupId": "org.kt3k.gradle.plugin",
-                    "version": "2.8.2"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "espresso-core",
-                    "groupId": "com.androidx.test.espresso",
-                    "version": "3.0.2"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "espresso-idling-resource",
-                    "groupId": "com.androidx.test.espresso",
-                    "version": "3.0.2"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "rules",
-                    "groupId": "com.androidx.test",
-                    "version": "1.2.0"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "appcompat",
-                    "groupId": "com.androidx.appcompat",
-                    "version": "1.0.2"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "browser",
-                    "groupId": "androidx.browser",
-                    "version": "1.0.0"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "Maven",
-                "maven": {
-                    "artifactId": "recyclerview",
-                    "groupId": "com.androidx.recyclerview",
-                    "version": "1.1.0"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "git",
-                "git": {
-                    "repositoryUrl": "https://android.googlesource.com/platform/frameworks/support",
-                    "commitHash": "cb7620b6f66a6e33fb9882bbca995a45c64f3c3e"
-                }
-            }
-        },
-        {
-            "component": {
-                "type": "git",
-                "git": {
-                    "repositoryUrl": "https://github.com/microsoft/appcenter-sdk-android-breakpad.git",
-                    "commitHash": "0d8e4133e2b9caadb012d438c4c12cf6daff2a40"
-                }
-            }
+  "$schema": "https://json.schemastore.org/component-detection-manifest.json",
+  "Registrations": [
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "gradle",
+          "groupId": "com.android.tools.build",
+          "version": "3.3.2"
         }
-    ],
-    "Version": 1
-}
\ No newline at end of file
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "gradle-bintray-plugin",
+          "groupId": "com.jfrog.bintray.gradle",
+          "version": "1.8.0"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "android-maven-gradle-plugin",
+          "groupId": "com.github.dcendents",
+          "version": "2.0"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "coveralls-gradle-plugin",
+          "groupId": "org.kt3k.gradle.plugin",
+          "version": "2.8.2"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "espresso-core",
+          "groupId": "com.androidx.test.espresso",
+          "version": "3.0.2"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "espresso-idling-resource",
+          "groupId": "com.androidx.test.espresso",
+          "version": "3.0.2"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "rules",
+          "groupId": "com.androidx.test",
+          "version": "1.2.0"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "appcompat",
+          "groupId": "com.androidx.appcompat",
+          "version": "1.0.2"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "browser",
+          "groupId": "androidx.browser",
+          "version": "1.0.0"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "Maven",
+        "maven": {
+          "artifactId": "recyclerview",
+          "groupId": "com.androidx.recyclerview",
+          "version": "1.1.0"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "git",
+        "git": {
+          "repositoryUrl": "https://android.googlesource.com/platform/frameworks/support",
+          "commitHash": "cb7620b6f66a6e33fb9882bbca995a45c64f3c3e"
+        }
+      }
+    },
+    {
+      "component": {
+        "type": "git",
+        "git": {
+          "repositoryUrl": "https://github.com/microsoft/appcenter-sdk-android-breakpad.git",
+          "commitHash": "0d8e4133e2b9caadb012d438c4c12cf6daff2a40"
+        }
+      }
+    }
+  ],
+  "Version": 1
+}
diff --git a/sdk/appcenter-distribute/src/main/AndroidManifest.xml b/sdk/appcenter-distribute/src/main/AndroidManifest.xml
index c621034b9b..02f6125fde 100644
--- a/sdk/appcenter-distribute/src/main/AndroidManifest.xml
+++ b/sdk/appcenter-distribute/src/main/AndroidManifest.xml
@@ -8,6 +8,7 @@
 
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
     <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <!--
      Android 11 brings in a lot of changes regarding privacy. By default, list of installed apps is now hidden.
@@ -24,8 +25,12 @@
     <application>
         <activity
             android:name="com.microsoft.appcenter.distribute.install.ReleaseInstallerActivity"
-            android:theme="@android:style/Theme.Translucent.NoTitleBar"
-            android:exported="false" />
+            android:exported="false"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
+        <activity
+            android:name="com.microsoft.appcenter.distribute.permissions.PermissionRequestActivity"
+            android:exported="false"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar" />
         <activity
             android:name="com.microsoft.appcenter.distribute.DeepLinkActivity"
             android:exported="true"
diff --git a/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/Distribute.java b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/Distribute.java
index d8b214a215..ba2c2e901b 100644
--- a/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/Distribute.java
+++ b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/Distribute.java
@@ -37,6 +37,7 @@
 import static com.microsoft.appcenter.distribute.DistributeConstants.PREFERENCE_KEY_UPDATE_TOKEN;
 import static com.microsoft.appcenter.distribute.DistributeConstants.SERVICE_NAME;
 
+import android.Manifest;
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.AlertDialog;
@@ -69,6 +70,8 @@
 import com.microsoft.appcenter.distribute.ingestion.DistributeIngestion;
 import com.microsoft.appcenter.distribute.ingestion.models.DistributionStartSessionLog;
 import com.microsoft.appcenter.distribute.ingestion.models.json.DistributionStartSessionLogFactory;
+import com.microsoft.appcenter.distribute.permissions.PermissionRequestActivity;
+import com.microsoft.appcenter.distribute.permissions.PermissionUtils;
 import com.microsoft.appcenter.http.HttpException;
 import com.microsoft.appcenter.http.HttpResponse;
 import com.microsoft.appcenter.http.HttpUtils;
@@ -595,7 +598,7 @@ public void accept(Boolean enabled) {
                 switch (updateAction) {
 
                     case UpdateAction.UPDATE:
-                        enqueueDownloadOrShowUnknownSourcesDialog(mReleaseDetails);
+                        enqueueDownloadAndRequestPermissions(mReleaseDetails);
                         break;
 
                     case UpdateAction.POSTPONE:
@@ -839,7 +842,7 @@ else if (mUnknownSourcesDialog != null) {
                  * We can start download if the setting is now enabled,
                  * otherwise restore dialog if activity rotated or was covered.
                  */
-                enqueueDownloadOrShowUnknownSourcesDialog(mReleaseDetails);
+                enqueueDownloadAndRequestPermissions(mReleaseDetails);
             }
 
             /*
@@ -1433,7 +1436,7 @@ private synchronized void showUpdateDialog() {
 
                 @Override
                 public void onClick(DialogInterface dialog, int which) {
-                    enqueueDownloadOrShowUnknownSourcesDialog(releaseDetails);
+                    enqueueDownloadAndRequestPermissions(releaseDetails);
                 }
             });
             dialogBuilder.setCancelable(false);
@@ -1662,33 +1665,64 @@ private synchronized void postponeRelease(ReleaseDetails releaseDetails) {
      *
      * @param releaseDetails release details.
      */
-    synchronized void enqueueDownloadOrShowUnknownSourcesDialog(final ReleaseDetails releaseDetails) {
+    synchronized void enqueueDownloadAndRequestPermissions(final ReleaseDetails releaseDetails) {
+
         if (releaseDetails == mReleaseDetails) {
-            if (InstallerUtils.isUnknownSourcesEnabled(mContext)) {
-                AppCenterLog.debug(LOG_TAG, "Schedule download...");
-                resumeDownload();
+            if (!InstallerUtils.isUnknownSourcesEnabled(mContext)) {
+                showUnknownSourcesDialog();
+                return;
+            }
+            requestPermissionsForDownload();
+            AppCenterLog.debug(LOG_TAG, "Schedule download...");
+            resumeDownload();
 
-                /* Refresh mandatory dialog progress or do nothing otherwise. */
-                showDownloadProgress();
+            /* Refresh mandatory dialog progress or do nothing otherwise. */
+            showDownloadProgress();
 
-                /*
-                 * If we restored a cached dialog, we also started a new check release call.
-                 * We might have time to click on download before the call completes (easy to
-                 * reproduce with network down).
-                 * In that case the download will start and we'll see a new update dialog if we
-                 * don't cancel the call.
-                 */
-                if (mCheckReleaseApiCall != null) {
-                    mCheckReleaseApiCall.cancel();
-                }
-            } else {
-                showUnknownSourcesDialog();
+            /*
+             * If we restored a cached dialog, we also started a new check release call.
+             * We might have time to click on download before the call completes (easy to
+             * reproduce with network down).
+             * In that case the download will start and we'll see a new update dialog if we
+             * don't cancel the call.
+             */
+            if (mCheckReleaseApiCall != null) {
+                mCheckReleaseApiCall.cancel();
             }
         } else {
             showDisabledToast();
         }
     }
 
+    private void requestPermissionsForDownload() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            AppCenterLog.debug(LOG_TAG, "There is no need to request permissions in runtime on Android earlier than 6.0.");
+            return;
+        }
+        if (PermissionUtils.permissionsAreGranted(mContext, Manifest.permission.POST_NOTIFICATIONS)) {
+            AppCenterLog.debug(LOG_TAG, "Post notification permission already granted.");
+            return;
+        }
+        AppCenterFuture<PermissionRequestActivity.Result> confirmFuture = PermissionUtils.requestPermissions(mContext, Manifest.permission.POST_NOTIFICATIONS);
+        if (confirmFuture == null) {
+            AppCenterLog.error(LOG_TAG, "Future to get the result of a permission request is null.");
+            return;
+        }
+        confirmFuture.thenAccept(new AppCenterConsumer<PermissionRequestActivity.Result>() {
+
+            @Override
+            public void accept(PermissionRequestActivity.Result result) {
+                if (result.exception != null) {
+                    AppCenterLog.warn(LOG_TAG, "Error when trying to request permissions.", result.exception);
+                } else if (result.areAllPermissionsGranted()) {
+                    AppCenterLog.info(LOG_TAG, "Permissions have been successfully granted.");
+                } else {
+                    AppCenterLog.info(LOG_TAG, "Permissions were not granted.");
+                }
+            }
+        });
+    }
+
     /**
      * Show disabled toast so that user is not surprised why the dialog action does not work.
      * Calling setEnabled(false) before actioning dialog is a corner case
@@ -1702,7 +1736,7 @@ private void showDisabledToast() {
     /**
      * Show toast using foreground activity context if possible.
      *
-      * @param messageId the resource id of the string resource to use.
+     * @param messageId the resource id of the string resource to use.
      */
     void showToast(int messageId) {
 
@@ -1926,4 +1960,4 @@ public void run() {
             }
         });
     }
-}
+}
\ No newline at end of file
diff --git a/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionRequestActivity.java b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionRequestActivity.java
new file mode 100644
index 0000000000..56c539ac93
--- /dev/null
+++ b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionRequestActivity.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+package com.microsoft.appcenter.distribute.permissions;
+
+import static com.microsoft.appcenter.distribute.DistributeConstants.LOG_TAG;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.microsoft.appcenter.utils.AppCenterLog;
+import com.microsoft.appcenter.utils.async.AppCenterFuture;
+import com.microsoft.appcenter.utils.async.DefaultAppCenterFuture;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Activity for requesting permissions.
+ */
+public class PermissionRequestActivity extends Activity {
+
+    /**
+     * Result of requesting permissions.
+     */
+    public static class Result {
+        public final Exception exception;
+        public final Map<String, Boolean> permissionRequestResults;
+
+        public Result(@Nullable Map<String, Boolean> permissionRequestResults, @Nullable Exception exception) {
+            this.permissionRequestResults = permissionRequestResults;
+            this.exception = exception;
+        }
+
+        public boolean areAllPermissionsGranted() {
+            if (permissionRequestResults != null && permissionRequestResults.size() > 0) {
+                return !permissionRequestResults.containsValue(false);
+            }
+            return false;
+        }
+    }
+
+    @VisibleForTesting
+    static final String EXTRA_PERMISSIONS = "intent.extra.PERMISSIONS";
+
+    @VisibleForTesting
+    static final int REQUEST_CODE = PermissionRequestActivity.class.getName().hashCode();
+
+    /**
+     * Tracking last request to send result to the listener.
+     */
+    @VisibleForTesting
+    static DefaultAppCenterFuture<Result> sResultFuture;
+
+    /**
+     * Start activity for requesting permissions.
+     *
+     * @param context The context from which the activity will be started.
+     * @param permissions List of requested permissions.
+     * @return Future with the result of a permissions request.
+     */
+    public static AppCenterFuture<Result> requestPermissions(@NonNull Context context, String... permissions) {
+        if (sResultFuture != null) {
+            AppCenterLog.error(LOG_TAG, "Result future flag is null.");
+            return null;
+        }
+        sResultFuture = new DefaultAppCenterFuture<>();
+        Intent intent = new Intent(context, PermissionRequestActivity.class);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+        intent.putExtra(EXTRA_PERMISSIONS, permissions);
+        context.startActivity(intent);
+        return sResultFuture;
+    }
+
+    @VisibleForTesting
+    static void complete(@NonNull Result result) {
+        if (sResultFuture != null) {
+            sResultFuture.complete(result);
+            sResultFuture = null;
+            return;
+        }
+        AppCenterLog.debug(LOG_TAG, "The start of the activity was not called using the requestPermissions function or the future has already been completed");
+    }
+
+    @Nullable
+    private String[] getPermissionsList() {
+        Intent intent = getIntent();
+        if (intent == null) {
+            return null;
+        }
+        Bundle extras = intent.getExtras();
+        if (extras == null) {
+            return null;
+        }
+        return extras.getStringArray(EXTRA_PERMISSIONS);
+    }
+
+    private Map<String, Boolean> getPermissionsRequestResultMap(String[] permissions, int[] results) {
+        Map<String, Boolean> resultsMap = new HashMap<>();
+        if (permissions.length != results.length) {
+            AppCenterLog.error(LOG_TAG, "Invalid argument array sizes.");
+            return null;
+        }
+        for (int i = 0; i < permissions.length; i++) {
+            resultsMap.put(permissions[i], results[i] == PackageManager.PERMISSION_GRANTED);
+        }
+        return resultsMap;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            Exception exception = new UnsupportedOperationException("There is no need to request permissions in runtime on Android earlier than 6.0.");
+            AppCenterLog.error(LOG_TAG, "Android version incompatible.", exception);
+            complete(new Result(null, exception));
+            finish();
+            return;
+        }
+        String[] permissions = getPermissionsList();
+        if (permissions == null) {
+            Exception exception = new IllegalArgumentException("Failed to get permissions list from intents extras.");
+            AppCenterLog.error(LOG_TAG, "Failed to get permissions list.", exception);
+            complete(new Result(null, exception));
+            finish();
+            return;
+        }
+        requestPermissions(permissions, REQUEST_CODE);
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (requestCode == REQUEST_CODE) {
+            Map<String, Boolean> results = getPermissionsRequestResultMap(permissions, grantResults);
+            if (results == null || results.size() == 0) {
+                complete(new Result(null, new IllegalArgumentException("Error while getting permission request results.")));
+                return;
+            }
+            complete(new Result(results, null));
+            finish();
+        }
+    }
+
+    @Override
+    public void finish() {
+        super.finish();
+
+        /*
+         * Prevent closing animation because we don't need any animation or visual effect
+         * from this wrapper activity.
+         */
+        overridePendingTransition(0, 0);
+    }
+}
\ No newline at end of file
diff --git a/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/PermissionUtils.java b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionUtils.java
similarity index 63%
rename from sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/PermissionUtils.java
rename to sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionUtils.java
index db7eef8a07..1efdc818cf 100644
--- a/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/PermissionUtils.java
+++ b/sdk/appcenter-distribute/src/main/java/com/microsoft/appcenter/distribute/permissions/PermissionUtils.java
@@ -3,11 +3,15 @@
  * Licensed under the MIT License.
  */
 
-package com.microsoft.appcenter.distribute;
+package com.microsoft.appcenter.distribute.permissions;
 
 import android.content.Context;
 import android.content.pm.PackageManager;
 
+import androidx.annotation.NonNull;
+
+import com.microsoft.appcenter.utils.async.AppCenterFuture;
+
 /**
  * Permission utils.
  */
@@ -32,6 +36,18 @@ public static int[] permissionsState(Context context, String... permissions) {
         return state;
     }
 
+    /**
+     * Checks if the specified permissions' states are equal to {@link PackageManager#PERMISSION_GRANTED}.
+     *
+     * @param context context.
+     * @param permissions an array with specified permissions.
+     * @return true if granted, false otherwise.
+     */
+    public static boolean permissionsAreGranted(Context context, String... permissions) {
+        int[] permissionsState = permissionsState(context, permissions);
+        return permissionsAreGranted(permissionsState);
+    }
+
     /**
      * Checks if the specified permissions' states are equal to {@link PackageManager#PERMISSION_GRANTED}.
      *
@@ -46,5 +62,9 @@ public static boolean permissionsAreGranted(int[] permissionsState) {
         }
         return true;
     }
+
+    public static AppCenterFuture<PermissionRequestActivity.Result> requestPermissions(@NonNull Context context, String... permissions) {
+        return PermissionRequestActivity.requestPermissions(context, permissions);
+    }
 }
 
diff --git a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeBeforeDownloadTest.java b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeBeforeDownloadTest.java
index 556d23201d..6e4ceb0f21 100644
--- a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeBeforeDownloadTest.java
+++ b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeBeforeDownloadTest.java
@@ -8,6 +8,7 @@
 import static com.microsoft.appcenter.Flags.DEFAULTS;
 import static com.microsoft.appcenter.distribute.DistributeConstants.DOWNLOAD_STATE_AVAILABLE;
 import static com.microsoft.appcenter.distribute.DistributeConstants.DOWNLOAD_STATE_COMPLETED;
+import static com.microsoft.appcenter.distribute.DistributeConstants.LOG_TAG;
 import static com.microsoft.appcenter.distribute.DistributeConstants.PREFERENCE_KEY_DISTRIBUTION_GROUP_ID;
 import static com.microsoft.appcenter.distribute.DistributeConstants.PREFERENCE_KEY_DOWNLOADED_RELEASE_HASH;
 import static com.microsoft.appcenter.distribute.DistributeConstants.PREFERENCE_KEY_DOWNLOADED_RELEASE_ID;
@@ -38,6 +39,7 @@
 import static org.powermock.api.mockito.PowerMockito.verifyStatic;
 import static org.powermock.api.mockito.PowerMockito.whenNew;
 
+import android.Manifest;
 import android.app.Activity;
 import android.app.ProgressDialog;
 import android.content.ActivityNotFoundException;
@@ -51,6 +53,8 @@
 import com.microsoft.appcenter.distribute.download.ReleaseDownloader;
 import com.microsoft.appcenter.distribute.download.ReleaseDownloaderFactory;
 import com.microsoft.appcenter.distribute.ingestion.models.DistributionStartSessionLog;
+import com.microsoft.appcenter.distribute.permissions.PermissionRequestActivity;
+import com.microsoft.appcenter.distribute.permissions.PermissionUtils;
 import com.microsoft.appcenter.http.HttpClient;
 import com.microsoft.appcenter.http.HttpResponse;
 import com.microsoft.appcenter.http.ServiceCall;
@@ -58,6 +62,7 @@
 import com.microsoft.appcenter.utils.AppCenterLog;
 import com.microsoft.appcenter.utils.AppNameHelper;
 import com.microsoft.appcenter.utils.AsyncTaskUtils;
+import com.microsoft.appcenter.utils.async.DefaultAppCenterFuture;
 import com.microsoft.appcenter.utils.context.SessionContext;
 import com.microsoft.appcenter.utils.storage.SharedPreferencesManager;
 
@@ -79,7 +84,8 @@
 @SuppressWarnings({"Convert2Lambda", "RedundantSuppression"})
 @PrepareForTest({
         DistributeUtils.class,
-        SessionContext.class
+        SessionContext.class,
+        PermissionUtils.class
 })
 public class DistributeBeforeDownloadTest extends AbstractDistributeTest {
 
@@ -1092,6 +1098,72 @@ public ServiceCall answer(InvocationOnMock invocation) {
         verify(mDialog).show();
     }
 
+    @Test
+    public void requestPermissionsForAndroid13() {
+        Distribute distribute = Distribute.getInstance();
+
+        /* Setup context field of the distribute instance. */
+        distribute.onStarted(mContext, mChannel, "appSecret", "targetToken", false);
+
+        /* Setup build version to TIRAMISU. */
+        Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.TIRAMISU);
+
+        /* Setup futures with return permission request results:
+         * 1) With exception.
+         * 2) With not granted permissions.
+         * 3) With granted permissions.
+         */
+        HashMap<String, Boolean> permissionRequestResults = new HashMap<>();
+        permissionRequestResults.put(Manifest.permission.POST_NOTIFICATIONS, true);
+        PermissionRequestActivity.Result permissionsRequestResultWithException = new PermissionRequestActivity.Result(null, new Exception());
+        PermissionRequestActivity.Result permissionsRequestResultNotGranted = new PermissionRequestActivity.Result(null, null);
+        PermissionRequestActivity.Result permissionsRequestResultGranted = new PermissionRequestActivity.Result(permissionRequestResults, null);
+        DefaultAppCenterFuture<PermissionRequestActivity.Result> resultFutureWithException = new DefaultAppCenterFuture<>();
+        DefaultAppCenterFuture<PermissionRequestActivity.Result> resultFutureNotGranted = new DefaultAppCenterFuture<>();
+        DefaultAppCenterFuture<PermissionRequestActivity.Result> resultFutureGranted = new DefaultAppCenterFuture<>();
+        resultFutureWithException.complete(permissionsRequestResultWithException);
+        resultFutureNotGranted.complete(permissionsRequestResultNotGranted);
+        resultFutureGranted.complete(permissionsRequestResultGranted);
+
+        /* Mock PermissionUtils methods. */
+        mockStatic(PermissionUtils.class);
+        when(PermissionUtils.permissionsAreGranted(eq(mContext), eq(Manifest.permission.POST_NOTIFICATIONS))).thenReturn(true).thenCallRealMethod();
+        when(PermissionUtils.requestPermissions(eq(mContext), eq(Manifest.permission.POST_NOTIFICATIONS)))
+                .thenReturn(null)
+                .thenReturn(resultFutureWithException)
+                .thenReturn(resultFutureNotGranted)
+                .thenReturn(resultFutureGranted);
+        when(InstallerUtils.isUnknownSourcesEnabled(eq(mContext))).thenReturn(true);
+
+        /* Mock AppCenterLog static methods. */
+        mockStatic(AppCenterLog.class);
+
+        /* Try to request permissions but them already granted. */
+        distribute.enqueueDownloadAndRequestPermissions(null);
+        verifyStatic(AppCenterLog.class, times(2));
+        AppCenterLog.debug(eq(LOG_TAG), anyString());
+
+        /* Try to request permissions but returned future is null. */
+        distribute.enqueueDownloadAndRequestPermissions(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.error(eq(LOG_TAG), anyString());
+
+        /* Try to request permissions with exception result. */
+        distribute.enqueueDownloadAndRequestPermissions(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.warn(eq(LOG_TAG), anyString(), any(Exception.class));
+
+        /* Try to request permissions with not granted permissions. */
+        distribute.enqueueDownloadAndRequestPermissions(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.info(eq(LOG_TAG), anyString());
+
+        /* Try to request permissions with granted permissions. */
+        distribute.enqueueDownloadAndRequestPermissions(null);
+        verifyStatic(AppCenterLog.class, times(2));
+        AppCenterLog.info(eq(LOG_TAG), anyString());
+    }
+
     @After
     public void tearDown() {
         Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", 0);
diff --git a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeCustomizationTest.java b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeCustomizationTest.java
index e04ca11d65..cd9111052e 100644
--- a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeCustomizationTest.java
+++ b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/DistributeCustomizationTest.java
@@ -589,7 +589,7 @@ public void handleUserUpdateActionDownloadForOptionalUpdate() throws Exception {
         distribute.handleUpdateAction(UpdateAction.UPDATE);
 
         /* Verify UPDATE has been processed. */
-        verify(distribute).enqueueDownloadOrShowUnknownSourcesDialog(any(ReleaseDetails.class));
+        verify(distribute).enqueueDownloadAndRequestPermissions(any(ReleaseDetails.class));
     }
 
     @Test
@@ -619,7 +619,7 @@ public void doNotShowUnknownSourcesDialogWhileInBackground() throws Exception {
         distribute.handleUpdateAction(UpdateAction.UPDATE);
 
         /* Verify UPDATE has not been processed. */
-        verify(distribute).enqueueDownloadOrShowUnknownSourcesDialog(any(ReleaseDetails.class));
+        verify(distribute).enqueueDownloadAndRequestPermissions(any(ReleaseDetails.class));
         verify(mDialogBuilder, never()).create();
     }
 
@@ -649,7 +649,7 @@ public void doShowUnknownSourcesDialogWhileInForeground() throws Exception {
         distribute.handleUpdateAction(UpdateAction.UPDATE);
 
         /* Verify UPDATE has been processed. */
-        verify(distribute).enqueueDownloadOrShowUnknownSourcesDialog(any(ReleaseDetails.class));
+        verify(distribute).enqueueDownloadAndRequestPermissions(any(ReleaseDetails.class));
         verify(mDialogBuilder).create();
     }
 
@@ -709,7 +709,7 @@ public void handleUserUpdateActionDownloadForMandatoryUpdate() throws Exception
         distribute.handleUpdateAction(UpdateAction.UPDATE);
 
         /* Verify UPDATE has been processed. */
-        verify(distribute).enqueueDownloadOrShowUnknownSourcesDialog(any(ReleaseDetails.class));
+        verify(distribute).enqueueDownloadAndRequestPermissions(any(ReleaseDetails.class));
     }
 
     @Test
@@ -770,7 +770,7 @@ public void notifyUserUpdateActionPostponeAndThenDownload() throws Exception {
         distribute.handleUpdateAction(UpdateAction.UPDATE);
 
         /* Verify UPDATE has NOT been processed. */
-        verify(distribute, never()).enqueueDownloadOrShowUnknownSourcesDialog(any(ReleaseDetails.class));
+        verify(distribute, never()).enqueueDownloadAndRequestPermissions(any(ReleaseDetails.class));
     }
 
     private ReleaseDetails mockForCustomizationTest(boolean mandatory) throws Exception {
diff --git a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/PermissionUtilsTest.java b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/PermissionUtilsTest.java
index 3c7122f3fe..d8a5acda0d 100644
--- a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/PermissionUtilsTest.java
+++ b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/PermissionUtilsTest.java
@@ -24,6 +24,8 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import com.microsoft.appcenter.distribute.permissions.PermissionUtils;
+
 @PrepareForTest({
         PermissionUtils.class,
         Context.class
diff --git a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsRequestActivityTest.java b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsRequestActivityTest.java
new file mode 100644
index 0000000000..e4ceaea22a
--- /dev/null
+++ b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsRequestActivityTest.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+package com.microsoft.appcenter.distribute.permissions;
+
+import static com.microsoft.appcenter.distribute.DistributeConstants.LOG_TAG;
+import static com.microsoft.appcenter.distribute.permissions.PermissionRequestActivity.EXTRA_PERMISSIONS;
+import static com.microsoft.appcenter.distribute.permissions.PermissionRequestActivity.REQUEST_CODE;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+import static org.powermock.api.mockito.PowerMockito.verifyStatic;
+
+import android.Manifest;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+
+import com.microsoft.appcenter.utils.AppCenterLog;
+import com.microsoft.appcenter.utils.async.DefaultAppCenterFuture;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.rule.PowerMockRule;
+import org.powermock.reflect.Whitebox;
+
+import java.util.HashMap;
+
+@PrepareForTest({
+        AppCenterLog.class,
+        PermissionRequestActivity.class
+})
+public class PermissionsRequestActivityTest {
+
+    @Rule
+    public PowerMockRule mPowerMockRule = new PowerMockRule();
+
+    @Mock
+    public Intent mIntent;
+
+    private PermissionRequestActivity mPermissionRequestActivity;
+
+    private void verifyCompleteWithIllegalArgumentException() {
+        PermissionRequestActivity.complete(ArgumentMatchers.argThat(new ArgumentMatcher<PermissionRequestActivity.Result>() {
+            @Override
+            public boolean matches(PermissionRequestActivity.Result argument) {
+                return argument.exception instanceof IllegalArgumentException &&
+                        !argument.areAllPermissionsGranted() &&
+                        argument.permissionRequestResults == null;
+            }
+        }));
+    }
+
+    private void verifyCompleteWithNotGrantedPermissions() {
+        PermissionRequestActivity.complete(ArgumentMatchers.argThat(new ArgumentMatcher<PermissionRequestActivity.Result>() {
+            @Override
+            public boolean matches(PermissionRequestActivity.Result argument) {
+                return argument.exception == null &&
+                        !argument.areAllPermissionsGranted() &&
+                        argument.permissionRequestResults != null &&
+                        Boolean.FALSE.equals(argument.permissionRequestResults.get(Manifest.permission.POST_NOTIFICATIONS));
+            }
+        }));
+    }
+
+    @Before
+    public void setUp() {
+        PermissionRequestActivity.sResultFuture = null;
+        mPermissionRequestActivity = spy(new PermissionRequestActivity());
+    }
+
+    @Test
+    public void onRequestPermissionsResultGranted() {
+        mockStatic(PermissionRequestActivity.class);
+        mPermissionRequestActivity.onRequestPermissionsResult(REQUEST_CODE, new String[]{Manifest.permission.POST_NOTIFICATIONS}, new int[]{PackageManager.PERMISSION_GRANTED});
+        verifyStatic(PermissionRequestActivity.class);
+        PermissionRequestActivity.complete(ArgumentMatchers.argThat(new ArgumentMatcher<PermissionRequestActivity.Result>() {
+            @Override
+            public boolean matches(PermissionRequestActivity.Result argument) {
+                return argument.exception == null &&
+                        argument.areAllPermissionsGranted() &&
+                        argument.permissionRequestResults != null &&
+                        Boolean.TRUE.equals(argument.permissionRequestResults.get(Manifest.permission.POST_NOTIFICATIONS));
+            }
+        }));
+    }
+
+    @Test
+    public void onRequestPermissionsResultNotGranted() {
+        mockStatic(PermissionRequestActivity.class);
+        mPermissionRequestActivity.onRequestPermissionsResult(REQUEST_CODE, new String[]{Manifest.permission.POST_NOTIFICATIONS}, new int[]{PackageManager.PERMISSION_DENIED});
+        verifyStatic(PermissionRequestActivity.class);
+        verifyCompleteWithNotGrantedPermissions();
+    }
+
+    @Test
+    public void onRequestPermissionsResultNotGrantedWithEmptyPermissionsList() {
+        mockStatic(PermissionRequestActivity.class);
+        mPermissionRequestActivity.onRequestPermissionsResult(REQUEST_CODE, new String[0], new int[]{PackageManager.PERMISSION_DENIED});
+        verifyStatic(PermissionRequestActivity.class);
+        verifyCompleteWithIllegalArgumentException();
+    }
+
+    @Test
+    public void onRequestPermissionsResultWithoutResponse() {
+        mockStatic(PermissionRequestActivity.class);
+        mPermissionRequestActivity.onRequestPermissionsResult(REQUEST_CODE, new String[0], new int[0]);
+        verifyStatic(PermissionRequestActivity.class);
+        verifyCompleteWithIllegalArgumentException();
+    }
+
+    @Test
+    public void onRequestPermissionsResultWithDifferentRequestCode() {
+        mockStatic(PermissionRequestActivity.class);
+        mPermissionRequestActivity.onRequestPermissionsResult(0, new String[]{Manifest.permission.POST_NOTIFICATIONS}, new int[]{PackageManager.PERMISSION_GRANTED});
+        verifyStatic(PermissionRequestActivity.class, never());
+        PermissionRequestActivity.complete(any(PermissionRequestActivity.Result.class));
+    }
+
+    @Test
+    public void completeWithNullFuture() {
+        mockStatic(AppCenterLog.class);
+        PermissionRequestActivity.complete(mock(PermissionRequestActivity.Result.class));
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.debug(eq(LOG_TAG), anyString());
+    }
+
+    @Test
+    public void complete() {
+        DefaultAppCenterFuture<PermissionRequestActivity.Result> futureMock = mock(DefaultAppCenterFuture.class);
+        PermissionRequestActivity.Result resultMock = mock(PermissionRequestActivity.Result.class);
+        PermissionRequestActivity.sResultFuture = futureMock;
+        PermissionRequestActivity.complete(resultMock);
+        verify(futureMock).complete(resultMock);
+        assertNull(PermissionRequestActivity.sResultFuture);
+    }
+
+    @Test
+    public void onCreateWithBuildVersionLowerThenM() {
+        mockStatic(AppCenterLog.class);
+        mockStatic(PermissionRequestActivity.class);
+
+        /* With build version lower then "Marshmallow" (6.0). */
+        Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.LOLLIPOP_MR1);
+        mPermissionRequestActivity.onCreate(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.error(eq(LOG_TAG), anyString(), any(Exception.class));
+        verifyStatic(PermissionRequestActivity.class);
+        PermissionRequestActivity.complete(ArgumentMatchers.argThat(new ArgumentMatcher<PermissionRequestActivity.Result>() {
+            @Override
+            public boolean matches(PermissionRequestActivity.Result argument) {
+                return argument.exception instanceof UnsupportedOperationException &&
+                        !argument.areAllPermissionsGranted() &&
+                        argument.permissionRequestResults == null;
+            }
+        }));
+    }
+
+    @Test
+    public void onCreateButIntentIsNull() {
+        mockStatic(AppCenterLog.class);
+        mockStatic(PermissionRequestActivity.class);
+
+        /* With "Marshmallow" (6.0) build version. */
+        Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
+        mPermissionRequestActivity.onCreate(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.error(eq(LOG_TAG), anyString(), any(Exception.class));
+        verifyStatic(PermissionRequestActivity.class);
+        verifyCompleteWithIllegalArgumentException();
+
+    }
+
+    @Test
+    public void onCreateButExtrasIsNull() {
+        mockStatic(AppCenterLog.class);
+        mockStatic(PermissionRequestActivity.class);
+
+        /* Setup getIntent() for mPermissionRequestActivity. */
+
+        when(mPermissionRequestActivity.getIntent()).thenReturn(mIntent);
+
+        /* With "Marshmallow" (6.0) build version. */
+        Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
+        mPermissionRequestActivity.onCreate(null);
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.error(eq(LOG_TAG), anyString(), any(Exception.class));
+        verifyStatic(PermissionRequestActivity.class);
+        verifyCompleteWithIllegalArgumentException();
+    }
+
+    @Test
+    public void onCreate() {
+        mockStatic(AppCenterLog.class);
+        mockStatic(PermissionRequestActivity.class);
+
+        /* Setup getIntent() for mPermissionRequestActivity. */
+        Bundle bundleMock = mock(Bundle.class);
+        when(mPermissionRequestActivity.getIntent()).thenReturn(mIntent);
+        when(mIntent.getExtras()).thenReturn(bundleMock);
+        String[] permissionsForRequest = {Manifest.permission.POST_NOTIFICATIONS};
+        when(bundleMock.getStringArray(eq(EXTRA_PERMISSIONS))).thenReturn(permissionsForRequest);
+
+        /* With "Marshmallow" (6.0) build version. */
+        Whitebox.setInternalState(Build.VERSION.class, "SDK_INT", Build.VERSION_CODES.M);
+        mPermissionRequestActivity.onCreate(null);
+        verify(mPermissionRequestActivity).requestPermissions(eq(permissionsForRequest), anyInt());
+    }
+
+    @Test
+    public void resultWithEmptyResultMap() {
+        PermissionRequestActivity.Result result = new PermissionRequestActivity.Result(new HashMap<>(), null);
+        assertFalse(result.areAllPermissionsGranted());
+    }
+}
diff --git a/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsUtilsTest.java b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsUtilsTest.java
new file mode 100644
index 0000000000..f2611eb37c
--- /dev/null
+++ b/sdk/appcenter-distribute/src/test/java/com/microsoft/appcenter/distribute/permissions/PermissionsUtilsTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+package com.microsoft.appcenter.distribute.permissions;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+
+import android.Manifest;
+import android.content.Context;
+
+import com.microsoft.appcenter.utils.async.AppCenterFuture;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.rule.PowerMockRule;
+
+@PrepareForTest
+public class PermissionsUtilsTest {
+
+    @Rule
+    public PowerMockRule mPowerMockRule = new PowerMockRule();
+
+    @Mock
+    public Context mContext;
+
+    @Before
+    public void setUp() {
+        PermissionRequestActivity.sResultFuture = null;
+    }
+
+    @Test
+    public void requestPermissions() {
+        AppCenterFuture<PermissionRequestActivity.Result> future = PermissionUtils.requestPermissions(mContext, Manifest.permission.POST_NOTIFICATIONS);
+        verify(mContext).startActivity(any());
+        assertNotNull(future);
+    }
+
+    @Test
+    public void requestPermissionsSecondTimeReturnNull() {
+        AppCenterFuture<PermissionRequestActivity.Result> future = PermissionUtils.requestPermissions(mContext, Manifest.permission.POST_NOTIFICATIONS);
+        assertNotNull(future);
+        future = PermissionUtils.requestPermissions(mContext, Manifest.permission.POST_NOTIFICATIONS);
+        assertNull(future);
+    }
+}
diff --git a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/persistence/DatabasePersistenceAndroidTest.java b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/persistence/DatabasePersistenceAndroidTest.java
index 1ce06159f3..eef7ead020 100644
--- a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/persistence/DatabasePersistenceAndroidTest.java
+++ b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/persistence/DatabasePersistenceAndroidTest.java
@@ -5,13 +5,33 @@
 
 package com.microsoft.appcenter.persistence;
 
+import static com.microsoft.appcenter.Flags.CRITICAL;
+import static com.microsoft.appcenter.Flags.NORMAL;
+import static com.microsoft.appcenter.ingestion.models.json.MockLog.MOCK_LOG_TYPE;
+import static com.microsoft.appcenter.persistence.DatabasePersistence.CREATE_LOGS_SQL;
+import static com.microsoft.appcenter.persistence.DatabasePersistence.SCHEMA;
+import static com.microsoft.appcenter.test.TestUtils.generateString;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
 import android.annotation.SuppressLint;
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteQueryBuilder;
-import androidx.annotation.NonNull;
 
+import androidx.annotation.NonNull;
 import androidx.test.filters.MediumTest;
 import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner;
 import androidx.test.platform.app.InstrumentationRegistry;
@@ -54,26 +74,6 @@
 import java.util.List;
 import java.util.Map;
 
-import static com.microsoft.appcenter.Flags.CRITICAL;
-import static com.microsoft.appcenter.Flags.NORMAL;
-import static com.microsoft.appcenter.ingestion.models.json.MockLog.MOCK_LOG_TYPE;
-import static com.microsoft.appcenter.persistence.DatabasePersistence.CREATE_LOGS_SQL;
-import static com.microsoft.appcenter.persistence.DatabasePersistence.SCHEMA;
-import static com.microsoft.appcenter.test.TestUtils.generateString;
-import static org.hamcrest.CoreMatchers.hasItems;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.anyString;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-
 @SuppressWarnings("TryFinallyCanBeTryWithResources")
 @MediumTest
 @RunWith(AndroidJUnit4ClassRunner.class)
@@ -1035,12 +1035,14 @@ public void getLogsException() throws PersistenceException, JSONException {
 
             /* Generate a log and persist. */
             Log[] logs = new Log[numberOfLogs];
-            for (int i = 0; i < logs.length; i++)
+            for (int i = 0; i < logs.length; i++) {
                 logs[i] = AndroidTestUtils.generateMockLog();
+            }
 
             /* Put. */
-            for (Log log : logs)
+            for (Log log : logs) {
                 persistence.putLog(log, "test", NORMAL);
+            }
 
             /* Get. */
             List<Log> outputLogs = new ArrayList<>();
@@ -1120,7 +1122,7 @@ public void upgradeFromVersion5to6() throws PersistenceException, JSONException
             ContentValues contentValues = new ContentValues();
             contentValues.put(DatabasePersistence.COLUMN_GROUP, "test");
             contentValues.put(DatabasePersistence.COLUMN_LOG, logSerializer.serializeLog(oldLog));
-            databaseManager.put(contentValues, DatabasePersistence.COLUMN_PRIORITY);
+            databaseManager.put(contentValues);
         } finally {
             databaseManager.close();
         }
diff --git a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/DatabaseManagerAndroidTest.java b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/DatabaseManagerAndroidTest.java
index 76354fa663..51a5944df4 100644
--- a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/DatabaseManagerAndroidTest.java
+++ b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/DatabaseManagerAndroidTest.java
@@ -5,6 +5,16 @@
 
 package com.microsoft.appcenter.utils.storage;
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
 import android.annotation.SuppressLint;
 import android.content.ContentValues;
 import android.content.Context;
@@ -12,9 +22,9 @@
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteQueryBuilder;
 
+import androidx.test.filters.SmallTest;
 import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner;
 import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.filters.SmallTest;
 
 import org.junit.After;
 import org.junit.BeforeClass;
@@ -23,16 +33,6 @@
 
 import java.util.Random;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
 @SuppressWarnings("unused")
 @SmallTest
 @RunWith(AndroidJUnit4ClassRunner.class)
@@ -120,11 +120,11 @@ private static void runDatabaseManagerTest(DatabaseManager databaseManager) {
         ContentValues value3 = generateContentValues();
 
         /* Put. */
-        long value1Id = databaseManager.put(value1, "COL_INTEGER");
+        long value1Id = databaseManager.put(value1);
         assertTrue(value1Id >= 0);
 
         /* Put another. */
-        long value2Id = databaseManager.put(value2, "COL_INTEGER");
+        long value2Id = databaseManager.put(value2);
         assertTrue(value2Id >= 0);
 
         /* Generate an ID that is neither value1Id nor value2Id. */
@@ -182,8 +182,8 @@ private static void runDatabaseManagerTest(DatabaseManager databaseManager) {
         ContentValues value5 = generateContentValues();
         value4.put("COL_STRING", value2.getAsString("COL_STRING"));
         value5.put("COL_STRING", value2.getAsString("COL_STRING") + "A");
-        long value4Id = databaseManager.put(value4, "COL_INTEGER");
-        long value5Id = databaseManager.put(value5, "COL_INTEGER");
+        long value4Id = databaseManager.put(value4);
+        long value5Id = databaseManager.put(value5);
         assertTrue(value4Id >= 0);
         assertTrue(value5Id >= 0);
 
diff --git a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/FileManagerAndroidTest.java b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/FileManagerAndroidTest.java
index 66d4854f18..8f0a3edf8b 100644
--- a/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/FileManagerAndroidTest.java
+++ b/sdk/appcenter/src/androidTest/java/com/microsoft/appcenter/utils/storage/FileManagerAndroidTest.java
@@ -5,7 +5,17 @@
 
 package com.microsoft.appcenter.utils.storage;
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.test.platform.app.InstrumentationRegistry;
 
 import org.junit.AfterClass;
@@ -21,13 +31,6 @@
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
 public class FileManagerAndroidTest {
 
     /**
@@ -40,6 +43,27 @@ public class FileManagerAndroidTest {
      */
     private static String sAndroidFilesPath;
 
+    /* Get an array of filenames in the path. */
+    @SuppressWarnings("WeakerAccess")
+    @NonNull
+    public static String[] getFilenames(@NonNull String path, @Nullable FilenameFilter filter) {
+        File dir = new File(path);
+        if (dir.exists()) {
+            String[] filenames = dir.list(filter);
+            if (filenames != null) {
+                return filenames;
+            }
+        }
+        return new String[0];
+    }
+
+    /* Get the most recently modified file in the directory specified. */
+    @SuppressWarnings("WeakerAccess")
+    @Nullable
+    public static File lastModifiedFile(@NonNull String path, @Nullable FilenameFilter filter) {
+        return FileManager.lastModifiedFile(new File(path), filter);
+    }
+
     @BeforeClass
     public static void setUpClass() {
         Context context = InstrumentationRegistry.getInstrumentation().getContext();
@@ -60,8 +84,7 @@ public boolean accept(File dir, String filename) {
                 return filename.endsWith(FILE_STORAGE_TEST_FILE_EXTENSION);
             }
         };
-
-        String[] filenames = FileManager.getFilenames(sAndroidFilesPath, filter);
+        String[] filenames = getFilenames(sAndroidFilesPath, filter);
 
         /* Delete the files to clean up. */
         for (String filename : filenames) {
@@ -109,7 +132,7 @@ public boolean accept(File dir, String filename) {
         FileManager.write(sAndroidFilesPath + filename4, "  ");
 
         /* Get file names in the root path. */
-        String[] filenames = FileManager.getFilenames(sAndroidFilesPath, filter);
+        String[] filenames = getFilenames(sAndroidFilesPath, filter);
 
         /* Verify the files are created. */
         assertNotNull(filenames);
@@ -121,7 +144,7 @@ public boolean accept(File dir, String filename) {
         assertFalse(list.contains(filename4));
 
         /* Get the most recent file. */
-        File lastModifiedFile = FileManager.lastModifiedFile(sAndroidFilesPath, filter);
+        File lastModifiedFile = lastModifiedFile(sAndroidFilesPath, filter);
 
         /* Verify the most recent file. */
         assertNotNull(lastModifiedFile);
@@ -140,12 +163,12 @@ public boolean accept(File dir, String filename) {
         }
 
         /* Verify all the files are properly deleted. */
-        assertEquals(0, FileManager.getFilenames(sAndroidFilesPath, filter).length);
+        assertEquals(0, getFilenames(sAndroidFilesPath, filter).length);
 
         /* Verify invalid accesses. */
         assertNull(FileManager.read("not-exist-filename"));
-        assertArrayEquals(new String[0], FileManager.getFilenames("not-exist-path", null));
-        assertNull(FileManager.lastModifiedFile("not-exist-path", null));
+        assertArrayEquals(new String[0], getFilenames("not-exist-path", null));
+        assertNull(lastModifiedFile("not-exist-path", null));
     }
 
     @Test
diff --git a/sdk/appcenter/src/main/java/com/microsoft/appcenter/http/HttpUtils.java b/sdk/appcenter/src/main/java/com/microsoft/appcenter/http/HttpUtils.java
index 558ac17612..a6b3da5aa4 100644
--- a/sdk/appcenter/src/main/java/com/microsoft/appcenter/http/HttpUtils.java
+++ b/sdk/appcenter/src/main/java/com/microsoft/appcenter/http/HttpUtils.java
@@ -87,7 +87,7 @@ public class HttpUtils {
     /**
      * One Collector Ingestion API key pattern (secret key within the header value).
      */
-    private static final Pattern API_KEY_PATTERN = Pattern.compile("-[^,]+(,|$)");
+    private static final Pattern API_KEY_PATTERN = Pattern.compile("-[^,]+(?<!-)(,|$)");
 
     @VisibleForTesting
     HttpUtils() {
diff --git a/sdk/appcenter/src/main/java/com/microsoft/appcenter/persistence/DatabasePersistence.java b/sdk/appcenter/src/main/java/com/microsoft/appcenter/persistence/DatabasePersistence.java
index d35674610a..877be7ac7e 100644
--- a/sdk/appcenter/src/main/java/com/microsoft/appcenter/persistence/DatabasePersistence.java
+++ b/sdk/appcenter/src/main/java/com/microsoft/appcenter/persistence/DatabasePersistence.java
@@ -5,11 +5,18 @@
 
 package com.microsoft.appcenter.persistence;
 
+import static com.microsoft.appcenter.AppCenter.LOG_TAG;
+import static com.microsoft.appcenter.utils.storage.DatabaseManager.OPERATION_FAILED_FLAG;
+import static com.microsoft.appcenter.utils.storage.DatabaseManager.PRIMARY_KEY;
+import static com.microsoft.appcenter.utils.storage.DatabaseManager.SELECT_PRIMARY_KEY;
+
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteFullException;
 import android.database.sqlite.SQLiteQueryBuilder;
+
 import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -29,6 +36,7 @@
 import org.json.JSONException;
 
 import java.io.File;
+import java.io.FilenameFilter;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -41,10 +49,6 @@
 import java.util.Set;
 import java.util.UUID;
 
-import static com.microsoft.appcenter.AppCenter.LOG_TAG;
-import static com.microsoft.appcenter.utils.storage.DatabaseManager.PRIMARY_KEY;
-import static com.microsoft.appcenter.utils.storage.DatabaseManager.SELECT_PRIMARY_KEY;
-
 @SuppressWarnings("TryFinallyCanBeTryWithResources")
 public class DatabasePersistence extends Persistence {
 
@@ -123,7 +127,8 @@ public class DatabasePersistence extends Persistence {
      * Size limit (in bytes) for a database row log payload.
      * A separate file is used if payload is larger.
      */
-    private static final int PAYLOAD_MAX_SIZE = (int) (1.9 * 1024 * 1024);
+    @VisibleForTesting
+    static final int PAYLOAD_MAX_SIZE = (int) (1.9 * 1024 * 1024);
 
     /**
      * Sub path for directory where to store large payloads.
@@ -152,7 +157,7 @@ public class DatabasePersistence extends Persistence {
      * SQL command to drop logs table
      */
     private static final String DROP_LOGS_SQL = "DROP TABLE `logs`";
-    
+
     /**
      * SQL command to create index for logs
      */
@@ -186,6 +191,11 @@ public class DatabasePersistence extends Persistence {
      */
     private final File mLargePayloadDirectory;
 
+    /**
+     * The size of the separated large files.
+     */
+    private long mLargePayloadsSize;
+
     /**
      * Initializes variables with default values.
      *
@@ -232,6 +242,8 @@ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 
         //noinspection ResultOfMethodCallIgnored we handle errors at read/write time for each file.
         mLargePayloadDirectory.mkdirs();
+
+        mLargePayloadsSize = checkLargePayloadFilesAndCollectTheirSize();
     }
 
     /**
@@ -257,7 +269,9 @@ private static ContentValues getContentValues(@Nullable String group, @Nullable
 
     @Override
     public boolean setMaxStorageSize(long maxStorageSizeInBytes) {
-        return mDatabaseManager.setMaxSize(maxStorageSizeInBytes);
+        boolean success = mDatabaseManager.setMaxSize(maxStorageSizeInBytes);
+        deleteLogsThatNotFitMaxSize();
+        return success;
     }
 
     @Override
@@ -286,16 +300,33 @@ public long putLog(@NonNull Log log, @NonNull String group, @IntRange(from = Fla
                 targetToken = null;
             }
             long maxSize = mDatabaseManager.getMaxSize();
-            if (maxSize == -1) {
+            if (maxSize == OPERATION_FAILED_FLAG) {
                 throw new PersistenceException("Failed to store a log to the Persistence database.");
             }
-            if (!isLargePayload && maxSize <= payloadSize) {
+            if (maxSize <= payloadSize) {
                 throw new PersistenceException("Log is too large (" + payloadSize + " bytes) to store in database. " +
                         "Current maximum database size is " + maxSize + " bytes.");
             }
-            contentValues = getContentValues(group, isLargePayload ? null : payload, targetToken, log.getType(), targetKey, Flags.getPersistenceFlag(flags, false));
-            long databaseId = mDatabaseManager.put(contentValues, COLUMN_PRIORITY);
-            if (databaseId == -1) {
+            int priority = Flags.getPersistenceFlag(flags, false);
+            contentValues = getContentValues(group, isLargePayload ? null : payload, targetToken, log.getType(), targetKey, priority);
+            while (isLargePayload && payloadSize + getStoredDataSize() > maxSize) {
+                AppCenterLog.debug(LOG_TAG, "Storage is full, trying to delete the oldest log that has the lowest priority which is lower or equal priority than the new log.");
+                if (deleteTheOldestLog(priority) == OPERATION_FAILED_FLAG) {
+                    throw new PersistenceException("Failed to clear space for new log record.");
+                }
+            }
+            Long databaseId = null;
+            while (databaseId == null) {
+                try {
+                    databaseId = mDatabaseManager.put(contentValues);
+                } catch (SQLiteFullException e) {
+                    AppCenterLog.debug(LOG_TAG, "Storage is full, trying to delete the oldest log that has the lowest priority which is lower or equal priority than the new log.");
+                    if (deleteTheOldestLog(priority) == OPERATION_FAILED_FLAG) {
+                        databaseId = OPERATION_FAILED_FLAG;
+                    }
+                }
+            }
+            if (databaseId == OPERATION_FAILED_FLAG) {
                 throw new PersistenceException("Failed to store a log to the Persistence database for log type " + log.getType() + ".");
             }
             AppCenterLog.debug(LOG_TAG, "Stored a log to the Persistence database for log type " + log.getType() + " with databaseId=" + databaseId);
@@ -308,6 +339,8 @@ public long putLog(@NonNull Log log, @NonNull String group, @IntRange(from = Fla
                 File payloadFile = getLargePayloadFile(directory, databaseId);
                 try {
                     FileManager.write(payloadFile, payload);
+                    mLargePayloadsSize += payloadFile.length();
+                    AppCenterLog.verbose(LOG_TAG, "Store extra " + payloadFile.length() + " KB as a separated payload file.");
                 } catch (IOException e) {
 
                     /* Remove database entry if we cannot save payload as a file. */
@@ -316,6 +349,7 @@ public long putLog(@NonNull Log log, @NonNull String group, @IntRange(from = Fla
                 }
                 AppCenterLog.debug(LOG_TAG, "Payload written to " + payloadFile);
             }
+            deleteLogsThatNotFitMaxSize();
             return databaseId;
         } catch (JSONException e) {
             throw new PersistenceException("Cannot convert to JSON string.", e);
@@ -465,7 +499,7 @@ public String getLogs(@NonNull String group, @NonNull Collection<String> pausedT
              */
             if (dbIdentifier == null) {
                 AppCenterLog.error(LOG_TAG, "Empty database record, probably content was larger than 2MB, need to delete as it's now corrupted.");
-                List<Long> corruptedIds = getLogsIds(builder, selectionArgsArray);
+                Set<Long> corruptedIds = getLogsIds(builder, selectionArgsArray);
                 for (Long corruptedId : corruptedIds) {
                     if (!mPendingDbIdentifiers.contains(corruptedId) && !candidates.containsKey(corruptedId)) {
 
@@ -579,8 +613,95 @@ public void close() {
         mDatabaseManager.close();
     }
 
-    private List<Long> getLogsIds(SQLiteQueryBuilder builder, String[] selectionArgs) {
-        List<Long> result = new ArrayList<>();
+    /**
+     * Delete the oldest logs that do not fit max storage size.
+     */
+    public void deleteLogsThatNotFitMaxSize() {
+        int normalPriority = Flags.getPersistenceFlag(Flags.NORMAL, false);
+        while (getStoredDataSize() >= mDatabaseManager.getMaxSize()) {
+            if (deleteTheOldestLog(normalPriority) == OPERATION_FAILED_FLAG) {
+                break;
+            }
+        }
+    }
+
+    private long getStoredDataSize() {
+        return mDatabaseManager.getCurrentSize() + mLargePayloadsSize;
+    }
+
+    /**
+     * Delete the log record from the database and the large payload file associated with this record if it exists.
+     *
+     * @param priority Value of maximum priority of record to delete.
+     * @return Id of deleted record.
+     */
+    private long deleteTheOldestLog(int priority) {
+        Set<String> columnsToGet = new HashSet<>();
+        columnsToGet.add(PRIMARY_KEY);
+        columnsToGet.add(COLUMN_GROUP);
+        ContentValues deletedRow = mDatabaseManager.deleteTheOldestRecord(columnsToGet, COLUMN_PRIORITY, priority);
+        if (deletedRow == null) {
+            return OPERATION_FAILED_FLAG;
+        }
+        long deletedId = deletedRow.getAsLong(PRIMARY_KEY);
+        String group = deletedRow.getAsString(COLUMN_GROUP);
+        File file = getLargePayloadFile(getLargePayloadGroupDirectory(group), deletedId);
+        if (!file.exists()) {
+            return deletedId;
+        }
+        long fileSize = file.length();
+        if (file.delete()) {
+            mLargePayloadsSize -= fileSize;
+            AppCenterLog.verbose(LOG_TAG, "Large payload file with id " + deletedId + " has been deleted. " + fileSize + " KB of memory has been freed.");
+        } else {
+            AppCenterLog.warn(LOG_TAG, "Cannot delete large payload file with id " + deletedId);
+        }
+        return deletedId;
+    }
+
+    private long checkLargePayloadFilesAndCollectTheirSize() {
+        FilenameFilter filter = new FilenameFilter() {
+            @Override
+            public boolean accept(File file, String fileName) {
+                return fileName.endsWith(PAYLOAD_FILE_EXTENSION);
+            }
+        };
+        long size = 0;
+        SQLiteQueryBuilder builder = SQLiteUtils.newSQLiteQueryBuilder();
+        Set<Long> logsIds = getLogsIds(builder);
+        File[] groupFiles = mLargePayloadDirectory.listFiles();
+        if (groupFiles == null) {
+            return size;
+        }
+        for (File groupFile : groupFiles) {
+            File[] files = groupFile.listFiles(filter);
+            if (files == null) {
+                continue;
+            }
+            for (File file : files) {
+                long id;
+                try {
+                    id = Integer.parseInt(FileManager.getNameWithoutExtension(file));
+                } catch (NumberFormatException exception) {
+                    AppCenterLog.warn(LOG_TAG, "A file was found whose name does not match the pattern of naming log files: " + file.getName());
+                    continue;
+                }
+                if (logsIds.contains(id)) {
+                    size += file.length();
+                    continue;
+                }
+                if (!file.delete()) {
+                    AppCenterLog.warn(LOG_TAG, "Cannot delete redundant large payload file with id " + id);
+                    continue;
+                }
+                AppCenterLog.debug(LOG_TAG, "Lasted large payload file with name " + file.getName() + " has been deleted.");
+            }
+        }
+        return size;
+    }
+
+    private Set<Long> getLogsIds(SQLiteQueryBuilder builder, String... selectionArgs) {
+        Set<Long> result = new HashSet<>();
         try {
             Cursor cursor = mDatabaseManager.getCursor(builder, SELECT_PRIMARY_KEY, selectionArgs, null);
             try {
diff --git a/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/DatabaseManager.java b/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/DatabaseManager.java
index 283f6a79d1..15ab0b946f 100644
--- a/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/DatabaseManager.java
+++ b/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/DatabaseManager.java
@@ -5,6 +5,8 @@
 
 package com.microsoft.appcenter.utils.storage;
 
+import static com.microsoft.appcenter.utils.AppCenterLog.LOG_TAG;
+
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
@@ -13,6 +15,7 @@
 import android.database.sqlite.SQLiteFullException;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteQueryBuilder;
+
 import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -21,9 +24,9 @@
 import com.microsoft.appcenter.utils.AppCenterLog;
 
 import java.io.Closeable;
+import java.io.File;
 import java.util.Arrays;
-
-import static com.microsoft.appcenter.utils.AppCenterLog.LOG_TAG;
+import java.util.Set;
 
 /**
  * Database manager for SQLite.
@@ -40,6 +43,11 @@ public class DatabaseManager implements Closeable {
      */
     public static final String[] SELECT_PRIMARY_KEY = {PRIMARY_KEY};
 
+    /**
+     * Flag indicating the failure of the database operation.
+     */
+    public static final long OPERATION_FAILED_FLAG = -1;
+
     /**
      * Application context instance.
      */
@@ -175,48 +183,22 @@ public ContentValues nextValues(Cursor cursor) {
      * new one can fit. If the log is larger than the max table size, database will be cleared and
      * the log is not inserted.
      *
-     * @param values         The entry to be stored.
-     * @param priorityColumn When storage full and deleting data, use this column to determine which entries to delete first.
+     * @param values The entry to be stored.
      * @return If a log was inserted, the database identifier. Otherwise -1.
+     *
+     * @throws SQLiteFullException Thrown if the storage is full when trying to insert.
      */
-    public long put(@NonNull ContentValues values, @NonNull String priorityColumn) {
-        Long id = null;
-        Cursor cursor = null;
+    public long put(@NonNull ContentValues values) throws SQLiteFullException {
+        long id;
         try {
-            while (id == null) {
-                try {
-
-                    /* Insert data. */
-                    id = getDatabase().insertOrThrow(mDefaultTable, null, values);
-                } catch (SQLiteFullException e) {
-
-                    /* Delete the oldest log. */
-                    AppCenterLog.debug(LOG_TAG, "Storage is full, trying to delete the oldest log that has the lowest priority which is lower or equal priority than the new log");
-                    if (cursor == null) {
-                        String priority = values.getAsString(priorityColumn);
-                        SQLiteQueryBuilder queryBuilder = SQLiteUtils.newSQLiteQueryBuilder();
-                        queryBuilder.appendWhere(priorityColumn + " <= ?");
-                        cursor = getCursor(queryBuilder, SELECT_PRIMARY_KEY, new String[]{priority}, priorityColumn + " , " + PRIMARY_KEY);
-                    }
-                    if (cursor.moveToNext()) {
-                        long deletedId = cursor.getLong(0);
-                        delete(deletedId);
-                        AppCenterLog.debug(LOG_TAG, "Deleted log id=" + deletedId);
-                    } else {
-                        throw e;
-                    }
-                }
-            }
+            /* Insert data. */
+            id = getDatabase().insertOrThrow(mDefaultTable, null, values);
+        } catch (SQLiteFullException e) {
+            throw e;
         } catch (RuntimeException e) {
-            id = -1L;
+            id = OPERATION_FAILED_FLAG;
             AppCenterLog.error(LOG_TAG, String.format("Failed to insert values (%s) to database %s.", values.toString(), mDatabase), e);
         }
-        if (cursor != null) {
-            try {
-                cursor.close();
-            } catch (RuntimeException ignore) {
-            }
-        }
         return id;
     }
 
@@ -229,6 +211,32 @@ public void delete(@IntRange(from = 0) long id) {
         delete(mDefaultTable, PRIMARY_KEY, id);
     }
 
+
+    /**
+     * Delete the oldest record from the database.
+     *
+     * @param columnsToReturn Set of deleted record column names whose values need to be returned.
+     * @param priorityColumn The name of the priority column for sorting records.
+     * @param priority Maximum record priority value to delete.
+     * @return Return values of fields of a deleted record.
+     */
+    @Nullable
+    public ContentValues deleteTheOldestRecord(@NonNull Set<String> columnsToReturn, @NonNull String priorityColumn, int priority) {
+        SQLiteQueryBuilder queryBuilder = SQLiteUtils.newSQLiteQueryBuilder();
+        queryBuilder.appendWhere(priorityColumn + " <= ?");
+        columnsToReturn.add(PRIMARY_KEY);
+        Cursor cursor = getCursor(queryBuilder, columnsToReturn.toArray(new String[0]), new String[]{String.valueOf(priority)}, priorityColumn + " , " + PRIMARY_KEY);
+        ContentValues rowData = nextValues(cursor);
+        if (rowData != null) {
+            long deletedId = rowData.getAsLong(PRIMARY_KEY);
+            delete(deletedId);
+            AppCenterLog.debug(LOG_TAG, "Deleted log id=" + deletedId);
+            return rowData;
+        }
+        AppCenterLog.error(LOG_TAG, String.format("Failed to delete the oldest log from database %s.", mDatabase));
+        return null;
+    }
+
     /**
      * Deletes the entries that matches key == value.
      *
@@ -293,7 +301,7 @@ public final long getRowCount() {
             return DatabaseUtils.queryNumEntries(getDatabase(), mDefaultTable);
         } catch (RuntimeException e) {
             AppCenterLog.error(LOG_TAG, "Failed to get row count of database.", e);
-            return -1;
+            return OPERATION_FAILED_FLAG;
         }
     }
 
@@ -414,10 +422,21 @@ public long getMaxSize() {
             return getDatabase().getMaximumSize();
         } catch (RuntimeException e) {
             AppCenterLog.error(LOG_TAG, "Could not get maximum database size.", e);
-            return -1;
+            return OPERATION_FAILED_FLAG;
         }
     }
 
+    /**
+     * Gets the current size of the database file.
+     * Disclaimer: The returned file size may not change immediately after performing SQL request.
+     *
+     * @return The current size of database in bytes.
+     */
+    public long getCurrentSize() {
+        File dbFile = mContext.getDatabasePath(mDatabase);
+        return dbFile.length();
+    }
+
     /**
      * Database listener.
      */
diff --git a/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/FileManager.java b/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/FileManager.java
index 81f5c4f1fd..12a5e828f8 100644
--- a/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/FileManager.java
+++ b/sdk/appcenter/src/main/java/com/microsoft/appcenter/utils/storage/FileManager.java
@@ -7,9 +7,10 @@
 
 import android.annotation.SuppressLint;
 import android.content.Context;
+import android.text.TextUtils;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import android.text.TextUtils;
 
 import com.microsoft.appcenter.AppCenter;
 import com.microsoft.appcenter.utils.AppCenterLog;
@@ -146,37 +147,6 @@ public static void write(@NonNull File file, @NonNull String contents) throws IO
         }
     }
 
-    /**
-     * Get an array of filenames in the path.
-     *
-     * @param path   The directory path.
-     * @param filter The filter to match file names against, may be {@code null}.
-     * @return An array of filename that doesn't include paths.
-     */
-    @SuppressWarnings("WeakerAccess")
-    @NonNull
-    public static String[] getFilenames(@NonNull String path, @Nullable FilenameFilter filter) {
-        File dir = new File(path);
-        if (dir.exists()) {
-            return dir.list(filter);
-        }
-
-        return new String[0];
-    }
-
-    /**
-     * Get the most recently modified file in the directory specified.
-     *
-     * @param path   The directory path.
-     * @param filter The filter to match file names against, may be {@code null}.
-     * @return The last modified file in the directory matching the specified filter, if any matches. {@code null} otherwise.
-     */
-    @SuppressWarnings("WeakerAccess")
-    @Nullable
-    public static File lastModifiedFile(@NonNull String path, @Nullable FilenameFilter filter) {
-        return lastModifiedFile(new File(path), filter);
-    }
-
     /**
      * Get the most recently modified file in the directory specified.
      *
@@ -198,7 +168,6 @@ public static File lastModifiedFile(@NonNull File dir, @Nullable FilenameFilter
                         lastModifiedFile = file;
                     }
                 }
-
                 return lastModifiedFile;
             }
         }
@@ -266,4 +235,20 @@ public static void cleanDirectory(@NonNull File directory) {
     public static void mkdir(@NonNull String path) {
         new File(path).mkdirs();
     }
+
+    /**
+     * Remove the extension part from filename.
+     *
+     * @param file The file which name without extension needed.
+     * @return Filename without extension.
+     */
+    @NonNull
+    public static String getNameWithoutExtension(@NonNull File file) {
+        String fileName = file.getName();
+        int indexOfLastDot = fileName.lastIndexOf(".");
+        if (indexOfLastDot > 0 && indexOfLastDot < fileName.length() - 1) {
+            return fileName.substring(0, indexOfLastDot);
+        }
+        return fileName;
+    }
 }
diff --git a/sdk/appcenter/src/test/java/com/microsoft/appcenter/persistence/DatabasePersistenceTest.java b/sdk/appcenter/src/test/java/com/microsoft/appcenter/persistence/DatabasePersistenceTest.java
index 5f2449645c..14c7c2fbcf 100644
--- a/sdk/appcenter/src/test/java/com/microsoft/appcenter/persistence/DatabasePersistenceTest.java
+++ b/sdk/appcenter/src/test/java/com/microsoft/appcenter/persistence/DatabasePersistenceTest.java
@@ -6,11 +6,15 @@
 package com.microsoft.appcenter.persistence;
 
 import static com.microsoft.appcenter.Flags.NORMAL;
+import static com.microsoft.appcenter.utils.storage.DatabaseManager.PRIMARY_KEY;
+import static com.microsoft.appcenter.persistence.DatabasePersistence.PAYLOAD_MAX_SIZE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anySet;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.isNotNull;
@@ -27,8 +31,11 @@
 import android.database.Cursor;
 import android.database.CursorWrapper;
 import android.database.sqlite.SQLiteDiskIOException;
+import android.database.sqlite.SQLiteFullException;
 import android.database.sqlite.SQLiteQueryBuilder;
 
+import androidx.annotation.Nullable;
+
 import com.microsoft.appcenter.AppCenter;
 import com.microsoft.appcenter.ingestion.models.Log;
 import com.microsoft.appcenter.ingestion.models.json.LogSerializer;
@@ -39,11 +46,17 @@
 import org.json.JSONException;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.rule.PowerMockRule;
+import org.powermock.modules.junit4.PowerMockRunner;
 
+import java.io.File;
+import java.io.FilenameFilter;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -54,22 +67,48 @@
         DatabaseManager.class,
         DatabasePersistence.class
 })
+@RunWith(PowerMockRunner.class)
 public class DatabasePersistenceTest {
 
     @Rule
-    public PowerMockRule mPowerMockRule = new PowerMockRule();
+    public TemporaryFolder mLargePayloadsFolder = new TemporaryFolder();
+
+    @Mock
+    private Context mContext;
+
+    @Mock
+    private DatabaseManager mDatabaseManager;
+
+    @Mock
+    private Cursor mCursor;
+
+    /* Create the DatabasePersistence with avoiding scanning large payload files. */
+    private DatabasePersistence createDatabasePersistenceInstance(
+            @Nullable Integer version,
+            @Nullable @SuppressWarnings("SameParameterValue") final ContentValues schema
+    ) throws Exception {
+        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(mDatabaseManager);
+        when(mCursor.moveToNext()).thenReturn(false);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), eq(null))).thenReturn(mCursor);
+        if (version == null || schema == null) {
+            return new DatabasePersistence(mContext);
+        } else {
+            return new DatabasePersistence(mContext, version, schema);
+        }
+    }
+
+    private DatabasePersistence createDatabasePersistenceInstance() throws Exception {
+        return createDatabasePersistenceInstance(null, null);
+    }
 
     @Test
     public void countLogsWithGetCountException() throws Exception {
 
         /* Mock instances. */
         mockStatic(AppCenterLog.class);
-        DatabaseManager mockDatabaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(mockDatabaseManager);
-        Cursor mockCursor = mock(Cursor.class);
-        when(mockCursor.moveToNext()).thenThrow(new RuntimeException());
-        when(mockDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString())).thenReturn(mockCursor);
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class), 1, DatabasePersistence.SCHEMA);
+        DatabasePersistence persistence = createDatabasePersistenceInstance(1, DatabasePersistence.SCHEMA);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString())).thenReturn(mCursor);
+        when(mCursor.moveToNext()).thenThrow(new RuntimeException());
 
         /* Try to get logs count. */
         //noinspection TryFinallyCanBeTryWithResources
@@ -107,22 +146,18 @@ public void clearPendingLogState() throws Exception {
         }
 
         /* Mock instances. */
-        DatabaseManager mockDatabaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(mockDatabaseManager);
-        when(mockDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
-
+        when(mDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
         for (int i = 0; i < groupCount; i++) {
             MockCursor mockCursor = new MockCursor(list.get(i));
-            mockCursor.mockBuildValues(mockDatabaseManager);
-            when(mockDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), eq(new String[]{String.valueOf(i)}), anyString()))
+            mockCursor.mockBuildValues(mDatabaseManager);
+            when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), eq(new String[]{String.valueOf(i)}), anyString()))
                     .thenReturn(mockCursor);
         }
-
         LogSerializer mockLogSerializer = mock(LogSerializer.class);
         when(mockLogSerializer.deserializeLog(anyString(), any())).thenReturn(mock(Log.class));
 
         /* Instantiate Database Persistence. */
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
         persistence.setLogSerializer(mockLogSerializer);
 
         /* Get logs. */
@@ -145,12 +180,9 @@ public void getLogsWithGetCursorException() throws Exception {
 
         /* Mock instances. */
         mockStatic(AppCenterLog.class);
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString()))
-                .thenThrow(new RuntimeException());
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class), 1, DatabasePersistence.SCHEMA);
+        when(mDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        DatabasePersistence persistence = createDatabasePersistenceInstance(1, DatabasePersistence.SCHEMA);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString())).thenThrow(new RuntimeException());
 
         /* Try to get logs. */
         ArrayList<Log> outLogs = new ArrayList<>();
@@ -167,13 +199,10 @@ public void getLogsWithMoveNextException() throws Exception {
 
         /* Mock instances. */
         mockStatic(AppCenterLog.class);
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
-        Cursor mockCursor = mock(Cursor.class);
-        when(mockCursor.moveToNext()).thenThrow(new RuntimeException());
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString())).thenReturn(mockCursor);
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class), 1, DatabasePersistence.SCHEMA);
+        when(mDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        DatabasePersistence persistence = createDatabasePersistenceInstance(1, DatabasePersistence.SCHEMA);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString())).thenReturn(mCursor);
+        when(mCursor.moveToNext()).thenThrow(new RuntimeException());
 
         /* Try to get logs. */
         ArrayList<Log> outLogs = new ArrayList<>();
@@ -190,9 +219,8 @@ public void getLogsWithGetCorruptedIdsException() throws Exception {
 
         /* Mock instances. */
         mockStatic(AppCenterLog.class);
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        when(mDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
 
         /* Make corrupted log. */
         List<ContentValues> fieldValues = new ArrayList<>();
@@ -205,16 +233,15 @@ public void getLogsWithGetCorruptedIdsException() throws Exception {
 
         /* Mock log sequence retrieved from cursor. */
         MockCursor mockCursor = new MockCursor(fieldValues);
-        mockCursor.mockBuildValues(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString())).thenReturn(mockCursor);
+        mockCursor.mockBuildValues(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString())).thenReturn(mockCursor);
 
         /* Mock second cursor with identifiers only. */
-        Cursor failingCursor = mock(Cursor.class);
+        Cursor failingCursor = mCursor;
         when(failingCursor.moveToNext()).thenThrow(new SQLiteDiskIOException());
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), anyString())).thenReturn(failingCursor);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), any())).thenReturn(failingCursor);
 
         /* Get logs and verify we get only non corrupted logs. */
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
         ArrayList<Log> outLogs = new ArrayList<>();
         persistence.getLogs("mock", Collections.emptyList(), 50, outLogs);
         assertEquals(0, outLogs.size());
@@ -229,9 +256,8 @@ public void getLogsWithCorruption() throws Exception {
 
         /* Mock instances. */
         int logCount = 3;
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        when(mDatabaseManager.nextValues(any(Cursor.class))).thenCallRealMethod();
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
 
         /* Make 3 logs, the second one will be corrupted. */
         List<ContentValues> fieldValues = new ArrayList<>(logCount);
@@ -258,8 +284,8 @@ public void getLogsWithCorruption() throws Exception {
 
         /* Mock log sequence retrieved from cursor. */
         MockCursor mockCursor = new MockCursor(fieldValues);
-        mockCursor.mockBuildValues(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString()))
+        mockCursor.mockBuildValues(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString()))
                 .thenReturn(mockCursor);
 
         /* Mock second cursor with identifiers only. */
@@ -270,8 +296,8 @@ public void getLogsWithCorruption() throws Exception {
             idValues.add(contentValues);
         }
         MockCursor mockIdCursor = new MockCursor(idValues);
-        mockIdCursor.mockBuildValues(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), isNull()))
+        mockIdCursor.mockBuildValues(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), isNull()))
                 .thenReturn(mockIdCursor);
 
         /* Mock serializer and eventually the database. */
@@ -287,7 +313,6 @@ public Log answer(InvocationOnMock invocation) {
                 return log;
             }
         });
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
         persistence.setLogSerializer(logSerializer);
 
         /* Get logs and verify we get only non corrupted logs. */
@@ -298,7 +323,7 @@ public Log answer(InvocationOnMock invocation) {
         assertEquals("last", outLogs.get(1).getType());
 
         /* Verify we detected and deleted the corrupted log, the second one. */
-        verify(databaseManager).delete(1);
+        verify(mDatabaseManager).delete(1);
 
         /* Verify next call is empty logs as they are pending. */
         outLogs = new ArrayList<>();
@@ -349,8 +374,8 @@ public void close() {
                 throw new RuntimeException();
             }
         };
-        mockCursor.mockBuildValues(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString()))
+        mockCursor.mockBuildValues(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNull(), any(String[].class), anyString()))
                 .thenReturn(mockCursor);
         idValues = new ArrayList<>(4);
 
@@ -369,9 +394,9 @@ public void close() {
                 throw new RuntimeException();
             }
         };
-        mockIdCursor.mockBuildValues(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), isNull()))
-                    .thenReturn(mockIdCursor);
+        mockIdCursor.mockBuildValues(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), isNotNull(), any(String[].class), isNull()))
+                .thenReturn(mockIdCursor);
 
         /* Verify next call is only the new valid log as others are marked pending. */
         outLogs = new ArrayList<>();
@@ -380,30 +405,176 @@ public void close() {
         assertEquals("true last", outLogs.get(0).getType());
 
         /* Verify that the only log we deleted in the entire test was the one from previous test (id=1). */
-        verify(databaseManager).delete(anyLong());
+        verify(mDatabaseManager).delete(anyLong());
     }
 
     @Test
     public void checkSetStorageSizeForwarding() throws Exception {
 
         /* The real Android test for checking size is in DatabaseManagerAndroidTest. */
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString()))
-                .thenReturn(mock(Cursor.class));
-        when(databaseManager.setMaxSize(anyLong())).thenReturn(true).thenReturn(false);
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), anyString()))
+                .thenReturn(mCursor);
+        when(mDatabaseManager.setMaxSize(anyLong())).thenReturn(true).thenReturn(false);
 
         /* Just checks calls are forwarded to the low level database layer. */
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
         assertTrue(persistence.setMaxStorageSize(20480));
         assertFalse(persistence.setMaxStorageSize(2));
     }
 
+    @Test(expected = PersistenceException.class)
+    public void failsToDeleteLogDuringPutWhenFull() throws Exception {
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
+
+        /* Set a mock log serializer. */
+        LogSerializer logSerializer = mock(LogSerializer.class);
+        String deserializedLog = "{name:\"MockLog\"}";
+        when(logSerializer.serializeLog(any(Log.class))).thenReturn(deserializedLog);
+        persistence.setLogSerializer(logSerializer);
+
+        /* Mock the database managers methods. */
+        when(mDatabaseManager.getMaxSize()).thenReturn((long) deserializedLog.getBytes(StandardCharsets.UTF_8).length * 3);
+        when(mDatabaseManager.deleteTheOldestRecord(anySet(), anyString(), anyInt())).thenReturn(null);
+        when(mDatabaseManager.put(any(ContentValues.class))).thenThrow(new SQLiteFullException());
+
+        /* Persist a log and throwing an exception when trying to free space for a new record. */
+        persistence.putLog(mock(Log.class), "mock", NORMAL);
+    }
+
+    @Test
+    public void successfullyFileDeletingWhileFileScanning() throws Exception {
+        /* Initialize mocks. */
+        ContentValues mockContentValues = mock(ContentValues.class);
+        mockStatic(AppCenterLog.class);
+
+        /* Setup behaviour for database manager, cursor and content values mocks. */
+        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), any())).thenReturn(mCursor);
+        when(mCursor.moveToNext()).thenReturn(true).thenReturn(false);
+        when(mDatabaseManager.buildValues(mCursor)).thenReturn(mockContentValues);
+        when(mockContentValues.getAsLong(PRIMARY_KEY)).thenReturn(1L);
+
+        /*
+         * Setup behaviour for files and directories mocks for searching in the file hierarchy.
+         * There are 6 iterations:
+         *  1) Directory without files.
+         *  2) Redundant file in the large payload directory.
+         *  3) File that corresponds with log id from database.
+         *  4) File that with name that cannot be converted to number.
+         *  5) Lasted log file that should be deleted successfully.
+         *  6) Redundant file in the group directory.
+         */
+        File largePayloadDirectory = mLargePayloadsFolder.getRoot();
+        File groupDirectoryFirst = mLargePayloadsFolder.newFolder("group1");
+        File groupDirectorySecond = mLargePayloadsFolder.newFolder("group2");
+        File redundantFileInLargePayloadDirectory = mLargePayloadsFolder.newFile("someFile.tmp");
+        File largePayloadFile = mLargePayloadsFolder.newFile("group2/1.json");
+        File largePayloadFileWithWrongName = mLargePayloadsFolder.newFile("group2/someName.json");
+        File lastedLargePayloadFile = mLargePayloadsFolder.newFile("group2/2.json");
+        File redundantFileInGroupDirectorySecond = mLargePayloadsFolder.newFile("group2/someFile.tmp");
+        whenNew(File.class).withAnyArguments().thenReturn(largePayloadDirectory);
+
+        /* Initialize files checking. */
+        Persistence persistence = new DatabasePersistence(mContext);
+
+        /* There is an warning log after file with name that cannot be converted to number. */
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.warn(eq(AppCenter.LOG_TAG), anyString());
+
+        /* There is an debug log after successfully deleting lasted file. */
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.debug(eq(AppCenter.LOG_TAG), anyString());
+    }
+
+    @Test
+    public void failedToDeleteFileWhileFileScanning() throws Exception {
+        /* Initialize mocks. */
+        ContentValues contentValues = new ContentValues();
+        contentValues.put(PRIMARY_KEY, 1L);
+        mockStatic(AppCenterLog.class);
+        File mockLargePayloadDirectory = mock(File.class);
+        File mockGroupDirectory = mock(File.class);
+        File mockLastedLargePayloadFileWithError = mock(File.class);
+
+        /* Setup behaviour for database manager, cursor and content values mocks. */
+        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(mDatabaseManager);
+        when(mDatabaseManager.getCursor(any(SQLiteQueryBuilder.class), any(), any(String[].class), any())).thenReturn(mCursor);
+        when(mCursor.moveToNext()).thenReturn(true).thenReturn(false);
+        when(mDatabaseManager.buildValues(mCursor)).thenReturn(contentValues);
+
+        /*
+         * Setup behaviour for files and directories mocks for searching in the file hierarchy.
+         * There would be the lasted log file that should be deleted unsuccessfully.
+         */
+        whenNew(File.class).withAnyArguments().thenReturn(mockLargePayloadDirectory);
+        when(mockLargePayloadDirectory.listFiles()).thenReturn(new File[]{mockGroupDirectory});
+        when(mockLastedLargePayloadFileWithError.getName()).thenReturn("3.json");
+        when(mockLastedLargePayloadFileWithError.delete()).thenReturn(false);
+        when(mockGroupDirectory.listFiles(any(FilenameFilter.class))).thenReturn(new File[]{mockLastedLargePayloadFileWithError});
+
+        /* Initialize files checking */
+        Persistence persistence = new DatabasePersistence(mContext);
+
+        /* Verification of try of file deleting. */
+        verify(mockLastedLargePayloadFileWithError).delete();
+
+        /* There is an warning log. */
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.warn(eq(AppCenter.LOG_TAG), anyString());
+    }
+
+    @Test
+    public void failedToDeleteLargePayloadFileWhatDoesNotFitMaxSize() throws Exception {
+        /* Initialize mocks. */
+        mockStatic(AppCenterLog.class);
+        Persistence persistence = createDatabasePersistenceInstance();
+        ContentValues mockContentValues = mock(ContentValues.class);
+        File mockGroupDirectory = mock(File.class);
+        File mockLargePayloadFile = mock(File.class);
+        File mockLargePayloadFileWithError = mock(File.class);
+        String logFileExtension = ".json";
+        String mockGroup = "mockGroup";
+        long logId = 1;
+        long errorLogId = 2;
+        long maxSize = 10;
+
+        /* Setup behaviour for database manager, cursor and content values mocks. */
+        when(mCursor.moveToNext()).thenReturn(true).thenReturn(false);
+        when(mDatabaseManager.setMaxSize(anyLong())).thenReturn(true);
+        when(mDatabaseManager.getMaxSize()).thenReturn(maxSize);
+        when(mDatabaseManager.getCurrentSize()).thenReturn(maxSize + 2).thenReturn(maxSize + 1).thenReturn(maxSize - 1);
+        when(mDatabaseManager.deleteTheOldestRecord(anySet(), anyString(), anyInt())).thenReturn(mockContentValues);
+        when(mockContentValues.getAsLong(PRIMARY_KEY)).thenReturn(logId).thenReturn(errorLogId);
+        when(mockContentValues.getAsString(DatabasePersistence.COLUMN_GROUP)).thenReturn(mockGroup);
+
+        /*
+         * Setup behaviour for files and directories mocks.
+         * There are 2 files: one with successfully deleting,
+         * one with error while deleting.
+         */
+        whenNew(File.class).withAnyArguments().thenReturn(mockGroupDirectory);
+        whenNew(File.class).withArguments(mockGroupDirectory, logId + logFileExtension).thenReturn(mockLargePayloadFile);
+        whenNew(File.class).withArguments(mockGroupDirectory, errorLogId + logFileExtension).thenReturn(mockLargePayloadFileWithError);
+        when(mockLargePayloadFile.exists()).thenReturn(true);
+        when(mockLargePayloadFile.delete()).thenReturn(true);
+        when(mockLargePayloadFileWithError.exists()).thenReturn(true);
+        when(mockLargePayloadFileWithError.delete()).thenReturn(false);
+
+        /* Initialize deleting of logs that not fit max storage size. */
+        persistence.setMaxStorageSize(maxSize);
+
+        /* There is an warning log. */
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.warn(eq(AppCenter.LOG_TAG), anyString());
+
+        /* Verification of tries of files deleting. */
+        verify(mockLargePayloadFile).delete();
+        verify(mockLargePayloadFileWithError).delete();
+    }
+
     @Test(expected = PersistenceException.class)
     public void putLogWithJSONException() throws Exception {
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
 
         /* Set a mock log serializer. */
         LogSerializer logSerializer = mock(LogSerializer.class);
@@ -416,10 +587,8 @@ public void putLogWithJSONException() throws Exception {
 
     @Test(expected = PersistenceException.class)
     public void putLogWithOpenDatabaseException() throws Exception {
-        DatabaseManager databaseManager = mock(DatabaseManager.class);
-        whenNew(DatabaseManager.class).withAnyArguments().thenReturn(databaseManager);
-        when(databaseManager.getMaxSize()).thenReturn(-1L);
-        DatabasePersistence persistence = new DatabasePersistence(mock(Context.class));
+        when(mDatabaseManager.getMaxSize()).thenReturn(-1L);
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
 
         /* Set a mock log serializer. */
         LogSerializer logSerializer = mock(LogSerializer.class);
@@ -430,6 +599,37 @@ public void putLogWithOpenDatabaseException() throws Exception {
         persistence.putLog(mock(Log.class), "test-p1", NORMAL);
     }
 
+    @Test(expected = PersistenceException.class)
+    public void putLargePayloadWhatDoNotFitMaxSizeFailed() throws Exception {
+        mockStatic(AppCenterLog.class);
+        DatabasePersistence persistence = createDatabasePersistenceInstance();
+        File mockLargePayloadFile = mock(File.class);
+        ContentValues mockContentValues = mock(ContentValues.class);
+
+        /* Set a mock of database manager. */
+        when(mDatabaseManager.getMaxSize()).thenReturn(PAYLOAD_MAX_SIZE + 2L);
+        when(mDatabaseManager.getCurrentSize()).thenReturn(2L);
+        when(mDatabaseManager.deleteTheOldestRecord(anySet(), anyString(), anyInt())).thenReturn(mockContentValues).thenReturn(null);
+
+        /* Set a mock payload. */
+        byte[] array = new byte[PAYLOAD_MAX_SIZE + 1];
+        String payloadMock = new String(array, StandardCharsets.UTF_8);
+
+        /* Set a mock log serializer. */
+        LogSerializer logSerializer = mock(LogSerializer.class);
+        when(logSerializer.serializeLog(any(Log.class))).thenReturn(payloadMock);
+        persistence.setLogSerializer(logSerializer);
+
+        /* Setup mock for the firs successful try of deleting the oldest log record. */
+        when(mockContentValues.getAsLong(PRIMARY_KEY)).thenReturn(1L);
+        when(mockContentValues.getAsString(DatabasePersistence.COLUMN_GROUP)).thenReturn("mockGroup");
+        whenNew(File.class).withAnyArguments().thenReturn(mockLargePayloadFile);
+        when(mockLargePayloadFile.exists()).thenReturn(false);
+
+        /* Persist a log. */
+        persistence.putLog(mock(Log.class), "test-p1", NORMAL);
+    }
+
     private static class MockCursor extends CursorWrapper {
 
         private final List<ContentValues> mList;
diff --git a/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/DatabaseManagerTest.java b/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/DatabaseManagerTest.java
index f8e0e014a8..ec9d9318c2 100644
--- a/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/DatabaseManagerTest.java
+++ b/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/DatabaseManagerTest.java
@@ -5,16 +5,30 @@
 
 package com.microsoft.appcenter.utils.storage;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+import static org.powermock.api.mockito.PowerMockito.verifyStatic;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
-import android.database.sqlite.SQLiteDiskIOException;
-import android.database.sqlite.SQLiteFullException;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteQueryBuilder;
 
 import com.microsoft.appcenter.AppCenter;
+import com.microsoft.appcenter.Flags;
 import com.microsoft.appcenter.utils.AppCenterLog;
 
 import org.junit.Before;
@@ -23,20 +37,7 @@
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.verifyStatic;
+import java.util.HashSet;
 
 @SuppressWarnings("unused")
 @RunWith(PowerMockRunner.class)
@@ -60,7 +61,7 @@ public void setUp() {
     @Test
     public void putFailed() {
         DatabaseManager databaseManagerMock = getDatabaseManagerMock();
-        databaseManagerMock.put(new ContentValues(), "priority");
+        databaseManagerMock.put(new ContentValues());
         verifyStatic(AppCenterLog.class);
         AppCenterLog.error(eq(AppCenter.LOG_TAG), anyString(), any(RuntimeException.class));
     }
@@ -175,62 +176,33 @@ public void getDatabaseException() {
     }
 
     @Test
-    public void failsToDeleteLogDuringPutWhenFull() {
-
+    public void failedToDeleteOldestRecord() throws Exception {
         /* Mocking instances. */
+        mockStatic(AppCenterLog.class);
         Context contextMock = mock(Context.class);
+        Cursor cursorMock = mock(Cursor.class);
+        SQLiteQueryBuilder queryBuilderMock = mock(SQLiteQueryBuilder.class);
         SQLiteOpenHelper helperMock = mock(SQLiteOpenHelper.class);
-        SQLiteDatabase sqLiteDatabase = mock(SQLiteDatabase.class);
-        when(helperMock.getWritableDatabase()).thenReturn(sqLiteDatabase);
+        SQLiteDatabase databaseMock = mock(SQLiteDatabase.class);
 
-        /* Mock the select cursor we are using to find logs to evict to fail. */
-        mockStatic(SQLiteUtils.class);
-        Cursor cursor = mock(Cursor.class);
-        SQLiteDiskIOException fatalException = new SQLiteDiskIOException();
-        when(cursor.moveToNext()).thenThrow(fatalException);
-        SQLiteQueryBuilder sqLiteQueryBuilder = mock(SQLiteQueryBuilder.class);
-        when(sqLiteQueryBuilder.query(any(), any(), any(), any(), any(), any(), any())).thenReturn(cursor);
-        when(SQLiteUtils.newSQLiteQueryBuilder()).thenReturn(sqLiteQueryBuilder);
+        /* Setup behaviour of the SQL stuff. */
+        whenNew(SQLiteQueryBuilder.class).withNoArguments().thenReturn(queryBuilderMock);
+        when(queryBuilderMock.query(any(SQLiteDatabase.class), any(String[].class), eq(null), any(String[].class), eq(null), eq(null), any(String.class))).thenReturn(cursorMock);
+        when(helperMock.getWritableDatabase()).thenReturn(databaseMock);
 
-        /* Simulate that database is full and that deletes fail because of the cursor. */
-        when(sqLiteDatabase.insertOrThrow(anyString(), isNull(), any(ContentValues.class))).thenThrow(new SQLiteFullException());
+        /* Setup behaviour of the cursor mock. */
+        when(cursorMock.moveToNext()).thenReturn(false);
+        when(cursorMock.getColumnCount()).thenReturn(0);
 
         /* Instantiate real instance for DatabaseManager. */
         DatabaseManager databaseManager = new DatabaseManager(contextMock, "database", "table", 1, null, null, null);
         databaseManager.setSQLiteOpenHelper(helperMock);
 
-        /* When we put a log, it will fail to purge. */
-        assertEquals(-1, databaseManager.put(mock(ContentValues.class), "priority"));
-    }
-
-    @Test
-    public void cursorFailsToCloseAfterPut() {
-
-        /* Mocking instances. */
-        Context contextMock = mock(Context.class);
-        SQLiteOpenHelper helperMock = mock(SQLiteOpenHelper.class);
-        SQLiteDatabase sqLiteDatabase = mock(SQLiteDatabase.class);
-        when(helperMock.getWritableDatabase()).thenReturn(sqLiteDatabase);
-
-        /* Mock the select cursor we are using to find logs to evict to fail. */
-        mockStatic(SQLiteUtils.class);
-        Cursor cursor = mock(Cursor.class);
-        SQLiteDiskIOException exception = new SQLiteDiskIOException();
-        doThrow(exception).when(cursor).close();
-        when(cursor.moveToNext()).thenReturn(true).thenReturn(false);
-        SQLiteQueryBuilder sqLiteQueryBuilder = mock(SQLiteQueryBuilder.class);
-        when(sqLiteQueryBuilder.query(any(), any(), any(), any(), any(), any(), any())).thenReturn(cursor);
-        when(SQLiteUtils.newSQLiteQueryBuilder()).thenReturn(sqLiteQueryBuilder);
-
-        /* Simulate that database is full only once (will work after purging 1 log). */
-        when(sqLiteDatabase.insertOrThrow(anyString(), isNull(), any(ContentValues.class))).thenThrow(new SQLiteFullException()).thenReturn(1L);
+        /* Try to delete the oldest log record. */
+        databaseManager.deleteTheOldestRecord(new HashSet<>(), "priorityColumn", Flags.NORMAL);
 
-        /* Instantiate real instance for DatabaseManager. */
-        DatabaseManager databaseManager = new DatabaseManager(contextMock, "database", "table", 1, null, null, null);
-        databaseManager.setSQLiteOpenHelper(helperMock);
-
-        /* When we put a log, it succeeds even if a problem occurred while closing purge cursor. */
-        long id = databaseManager.put(mock(ContentValues.class), "priority");
-        assertEquals(1, id);
+        /* There is an error log. */
+        verifyStatic(AppCenterLog.class);
+        AppCenterLog.error(eq(AppCenter.LOG_TAG), anyString());
     }
 }
\ No newline at end of file
diff --git a/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/FileManagerTest.java b/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/FileManagerTest.java
index 7701683f68..fa650262e8 100644
--- a/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/FileManagerTest.java
+++ b/sdk/appcenter/src/test/java/com/microsoft/appcenter/utils/storage/FileManagerTest.java
@@ -5,6 +5,22 @@
 
 package com.microsoft.appcenter.utils.storage;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.mock;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+import static org.powermock.api.mockito.PowerMockito.spy;
+import static org.powermock.api.mockito.PowerMockito.verifyStatic;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
 import android.text.TextUtils;
 
 import com.microsoft.appcenter.utils.AppCenterLog;
@@ -28,22 +44,6 @@
 import java.io.FilenameFilter;
 import java.io.IOException;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.spy;
-import static org.powermock.api.mockito.PowerMockito.verifyStatic;
-import static org.powermock.api.mockito.PowerMockito.whenNew;
-
 @SuppressWarnings("unused")
 @PrepareForTest({FileManager.class, AppCenterLog.class, TextUtils.class})
 public class FileManagerTest {
@@ -242,4 +242,38 @@ public void cleanDirectoryWhenNotDirectory() throws IOException {
         /* Verify when directory is not directory, that no crashes happen */
         FileManager.cleanDirectory(file1);
     }
+
+    @Test
+    public void getNameWithDotAtTheEnd() {
+        File mockFile = mock(File.class);
+        String fileName = "someName.";
+        when(mockFile.getName()).thenReturn(fileName);
+        String result = FileManager.getNameWithoutExtension(mockFile);
+        assertEquals(result, fileName);
+    }
+
+    @Test
+    public void getNameWithDotAtTheStart() {
+        File mockFile = mock(File.class);
+        String fileName = ".someName";
+        when(mockFile.getName()).thenReturn(fileName);
+        String result = FileManager.getNameWithoutExtension(mockFile);
+        assertEquals(result, fileName);
+    }
+
+    @Test
+    public void getNameWithOutExtension() {
+        File mockFile = mock(File.class);
+        when(mockFile.getName()).thenReturn("someName.ext");
+        String result = FileManager.getNameWithoutExtension(mockFile);
+        assertEquals(result, "someName");
+    }
+
+    @Test
+    public void getNameWithDotsWithOutExtension() {
+        File mockFile = mock(File.class);
+        when(mockFile.getName()).thenReturn("someName.someInfo.ext");
+        String result = FileManager.getNameWithoutExtension(mockFile);
+        assertEquals(result, "someName.someInfo");
+    }
 }
diff --git a/versions.gradle b/versions.gradle
index 97a69409e6..382f0d44c6 100644
--- a/versions.gradle
+++ b/versions.gradle
@@ -6,10 +6,10 @@
 // Version constants
 
 ext {
-    versionCode = 68
-    versionName = '4.4.5'
+    versionCode = 69
+    versionName = '5.0.0'
     minSdkVersion = 21
-    compileSdkVersion = 31
-    targetSdkVersion = 31
+    compileSdkVersion = 33
+    targetSdkVersion = 33
     annotationVersion = '1.2.0'
-}
+}
\ No newline at end of file