Fixed a few bugs, added logging and removed some old code

Added the ability to copy the sessionId of open group URL from the conversation menu
Added additional logging to the BatchMessageReceiveJob to make future debugging easier
Removed the OpenGroupMigrator
Updated the JobQueue logging to provide more insight
Fixed an issue where the database migrations weren't blocking which could result in failing/crashing SQL queries
Fixed an issue where the new database file wouldn't be removed if a migration error was thrown
Fixed an issue where the new database could exist in an invalid state and the app wouldn't attempt to remigrate
Fixed an incorrectly throw exception in the PassphrasePromptActivity

libsession/src/main/java/org/session/libsession/messaging/jobs/AttachmentDownloadJob.kt

@@ -42,7 +42,7 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
         private val TS_INCOMING_MESSAGE_ID_KEY = "tsIncoming_message_id"
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val storage = MessagingModuleConfiguration.shared.storage
         val messageDataProvider = MessagingModuleConfiguration.shared.messageDataProvider
         val threadID = storage.getThreadIdForMms(databaseMessageID)
@@ -59,7 +59,7 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
                     Log.d("AttachmentDownloadJob", "Setting attachment state = failed, don't have attachment")
                     messageDataProvider.setAttachmentState(AttachmentState.FAILED, AttachmentId(attachmentID,0), databaseMessageID)
                 }
-                this.handlePermanentFailure(exception)
+                this.handlePermanentFailure(dispatcherName, exception)
             } else if (exception == Error.DuplicateData) {
                 attachment?.let { id ->
                     Log.d("AttachmentDownloadJob", "Setting attachment state = done from duplicate data")
@@ -68,7 +68,7 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
                     Log.d("AttachmentDownloadJob", "Setting attachment state = done from duplicate data")
                     messageDataProvider.setAttachmentState(AttachmentState.DONE, AttachmentId(attachmentID,0), databaseMessageID)
                 }
-                this.handleSuccess()
+                this.handleSuccess(dispatcherName)
             } else {
                 if (failureCount + 1 >= maxFailureCount) {
                     attachment?.let { id ->
@@ -79,7 +79,7 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
                         messageDataProvider.setAttachmentState(AttachmentState.FAILED, AttachmentId(attachmentID,0), databaseMessageID)
                     }
                 }
-                this.handleFailure(exception)
+                this.handleFailure(dispatcherName, exception)
             }
         }
 
@@ -150,7 +150,7 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
             Log.d("AttachmentDownloadJob", "deleting tempfile")
             tempFile.delete()
             Log.d("AttachmentDownloadJob", "succeeding job")
-            handleSuccess()
+            handleSuccess(dispatcherName)
         } catch (e: Exception) {
             Log.e("AttachmentDownloadJob", "Error processing attachment download", e)
             tempFile?.delete()
@@ -169,17 +169,17 @@ class AttachmentDownloadJob(val attachmentID: Long, val databaseMessageID: Long)
         }
     }
 
-    private fun handleSuccess() {
+    private fun handleSuccess(dispatcherName: String) {
         Log.w("AttachmentDownloadJob", "Attachment downloaded successfully.")
-        delegate?.handleJobSucceeded(this)
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
-    private fun handlePermanentFailure(e: Exception) {
-        delegate?.handleJobFailedPermanently(this, e)
+    private fun handlePermanentFailure(dispatcherName: String, e: Exception) {
+        delegate?.handleJobFailedPermanently(this, dispatcherName, e)
     }
 
-    private fun handleFailure(e: Exception) {
-        delegate?.handleJobFailed(this, e)
+    private fun handleFailure(dispatcherName: String, e: Exception) {
+        delegate?.handleJobFailed(this, dispatcherName, e)
     }
 
     private fun createTempFile(): File {

libsession/src/main/java/org/session/libsession/messaging/jobs/AttachmentUploadJob.kt

@@ -45,29 +45,29 @@ class AttachmentUploadJob(val attachmentID: Long, val threadID: String, val mess
         private val MESSAGE_SEND_JOB_ID_KEY = "message_send_job_id"
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         try {
             val storage = MessagingModuleConfiguration.shared.storage
             val messageDataProvider = MessagingModuleConfiguration.shared.messageDataProvider
             val attachment = messageDataProvider.getScaledSignalAttachmentStream(attachmentID)
-                ?: return handleFailure(Error.NoAttachment)
+                ?: return handleFailure(dispatcherName, Error.NoAttachment)
             val openGroup = storage.getOpenGroup(threadID.toLong())
             if (openGroup != null) {
                 val keyAndResult = upload(attachment, openGroup.server, false) {
                     OpenGroupApi.upload(it, openGroup.room, openGroup.server)
                 }
-                handleSuccess(attachment, keyAndResult.first, keyAndResult.second)
+                handleSuccess(dispatcherName, attachment, keyAndResult.first, keyAndResult.second)
             } else {
                 val keyAndResult = upload(attachment, FileServerApi.server, true) {
                     FileServerApi.upload(it)
                 }
-                handleSuccess(attachment, keyAndResult.first, keyAndResult.second)
+                handleSuccess(dispatcherName, attachment, keyAndResult.first, keyAndResult.second)
             }
         } catch (e: java.lang.Exception) {
             if (e == Error.NoAttachment) {
-                this.handlePermanentFailure(e)
+                this.handlePermanentFailure(dispatcherName, e)
             } else {
-                this.handleFailure(e)
+                this.handleFailure(dispatcherName, e)
             }
         }
     }
@@ -104,9 +104,9 @@ class AttachmentUploadJob(val attachmentID: Long, val threadID: String, val mess
         return Pair(key, UploadResult(id, "${server}/file/$id", digest))
     }
 
-    private fun handleSuccess(attachment: SignalServiceAttachmentStream, attachmentKey: ByteArray, uploadResult: UploadResult) {
+    private fun handleSuccess(dispatcherName: String, attachment: SignalServiceAttachmentStream, attachmentKey: ByteArray, uploadResult: UploadResult) {
         Log.d(TAG, "Attachment uploaded successfully.")
-        delegate?.handleJobSucceeded(this)
+        delegate?.handleJobSucceeded(this, dispatcherName)
         val messageDataProvider = MessagingModuleConfiguration.shared.messageDataProvider
         messageDataProvider.handleSuccessfulAttachmentUpload(attachmentID, attachment, attachmentKey, uploadResult)
         if (attachment.contentType.startsWith("audio/")) {
@@ -144,16 +144,16 @@ class AttachmentUploadJob(val attachmentID: Long, val threadID: String, val mess
         storage.resumeMessageSendJobIfNeeded(messageSendJobID)
     }
 
-    private fun handlePermanentFailure(e: Exception) {
+    private fun handlePermanentFailure(dispatcherName: String, e: Exception) {
         Log.w(TAG, "Attachment upload failed permanently due to error: $this.")
-        delegate?.handleJobFailedPermanently(this, e)
+        delegate?.handleJobFailedPermanently(this, dispatcherName, e)
         MessagingModuleConfiguration.shared.messageDataProvider.handleFailedAttachmentUpload(attachmentID)
         failAssociatedMessageSendJob(e)
     }
 
-    private fun handleFailure(e: Exception) {
+    private fun handleFailure(dispatcherName: String, e: Exception) {
         Log.w(TAG, "Attachment upload failed due to error: $this.")
-        delegate?.handleJobFailed(this, e)
+        delegate?.handleJobFailed(this, dispatcherName, e)
         if (failureCount + 1 >= maxFailureCount) {
             failAssociatedMessageSendJob(e)
         }

libsession/src/main/java/org/session/libsession/messaging/jobs/BackgroundGroupAddJob.kt

@@ -29,14 +29,14 @@ class BackgroundGroupAddJob(val joinUrl: String): Job {
         return "$server.$room"
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         try {
             val openGroup = OpenGroupUrlParser.parseUrl(joinUrl)
             val storage = MessagingModuleConfiguration.shared.storage
             val allOpenGroups = storage.getAllOpenGroups().map { it.value.joinURL }
             if (allOpenGroups.contains(openGroup.joinUrl())) {
                 Log.e("OpenGroupDispatcher", "Failed to add group because", DuplicateGroupException())
-                delegate?.handleJobFailed(this, DuplicateGroupException())
+                delegate?.handleJobFailed(this, dispatcherName, DuplicateGroupException())
                 return
             }
             // get image
@@ -50,11 +50,11 @@ class BackgroundGroupAddJob(val joinUrl: String): Job {
             storage.onOpenGroupAdded(openGroup.server)
         } catch (e: Exception) {
             Log.e("OpenGroupDispatcher", "Failed to add group because",e)
-            delegate?.handleJobFailed(this, e)
+            delegate?.handleJobFailed(this, dispatcherName, e)
             return
         }
         Log.d("Loki", "Group added successfully")
-        delegate?.handleJobSucceeded(this)
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
     override fun serialize(): Data = Data.Builder()

libsession/src/main/java/org/session/libsession/messaging/jobs/BatchMessageReceiveJob.kt

@@ -66,11 +66,11 @@ class BatchMessageReceiveJob(
         return storage.getOrCreateThreadIdFor(senderOrSync, message.groupPublicKey, openGroupID)
     }
 
-    override fun execute() {
-        executeAsync().get()
+    override fun execute(dispatcherName: String) {
+        executeAsync(dispatcherName).get()
     }
 
-    fun executeAsync(): Promise<Unit, Exception> {
+    fun executeAsync(dispatcherName: String): Promise<Unit, Exception> {
         return task {
             val threadMap = mutableMapOf<Long, MutableList<ParsedMessage>>()
             val storage = MessagingModuleConfiguration.shared.storage
@@ -188,19 +188,21 @@ class BatchMessageReceiveJob(
                 deferredThreadMap.awaitAll()
             }
             if (failures.isEmpty()) {
-                handleSuccess()
+                handleSuccess(dispatcherName)
             } else {
-                handleFailure()
+                handleFailure(dispatcherName)
             }
         }
     }
 
-    private fun handleSuccess() {
-        this.delegate?.handleJobSucceeded(this)
+    private fun handleSuccess(dispatcherName: String) {
+        Log.i(TAG, "Completed processing of ${messages.size} messages")
+        this.delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
-    private fun handleFailure() {
-        this.delegate?.handleJobFailed(this, Exception("One or more jobs resulted in failure"))
+    private fun handleFailure(dispatcherName: String) {
+        Log.i(TAG, "Handling failure of ${failures.size} messages (${messages.size - failures.size} processed successfully)")
+        this.delegate?.handleJobFailed(this, dispatcherName, Exception("One or more jobs resulted in failure"))
     }
 
     override fun serialize(): Data {

libsession/src/main/java/org/session/libsession/messaging/jobs/GroupAvatarDownloadJob.kt

@@ -12,7 +12,7 @@ class GroupAvatarDownloadJob(val room: String, val server: String) : Job {
     override var failureCount: Int = 0
     override val maxFailureCount: Int = 10
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val storage = MessagingModuleConfiguration.shared.storage
         val imageId = storage.getOpenGroup(room, server)?.imageId ?: return
         try {
@@ -20,9 +20,9 @@ class GroupAvatarDownloadJob(val room: String, val server: String) : Job {
             val groupId = GroupUtil.getEncodedOpenGroupID("$server.$room".toByteArray())
             storage.updateProfilePicture(groupId, bytes)
             storage.updateTimestampUpdated(groupId, System.currentTimeMillis())
-            delegate?.handleJobSucceeded(this)
+            delegate?.handleJobSucceeded(this, dispatcherName)
         } catch (e: Exception) {
-            delegate?.handleJobFailed(this, e)
+            delegate?.handleJobFailed(this, dispatcherName, e)
         }
     }
 

libsession/src/main/java/org/session/libsession/messaging/jobs/Job.kt

@@ -17,7 +17,7 @@ interface Job {
         internal const val MAX_BUFFER_SIZE = 1_000_000 // bytes
     }
 
-    fun execute()
+    fun execute(dispatcherName: String)
 
     fun serialize(): Data
 

libsession/src/main/java/org/session/libsession/messaging/jobs/JobDelegate.kt

@@ -2,7 +2,7 @@ package org.session.libsession.messaging.jobs
 
 interface JobDelegate {
 
-    fun handleJobSucceeded(job: Job)
-    fun handleJobFailed(job: Job, error: Exception)
-    fun handleJobFailedPermanently(job: Job, error: Exception)
+    fun handleJobSucceeded(job: Job, dispatcherName: String)
+    fun handleJobFailed(job: Job, dispatcherName: String, error: Exception)
+    fun handleJobFailedPermanently(job: Job, dispatcherName: String, error: Exception)
 }

libsession/src/main/java/org/session/libsession/messaging/jobs/JobQueue.kt

@@ -53,7 +53,7 @@ class JobQueue : JobDelegate {
             }
             if (openGroupId.isNullOrEmpty()) {
                 Log.e("OpenGroupDispatcher", "Open Group ID was null on ${job.javaClass.simpleName}")
-                handleJobFailedPermanently(job, NullPointerException("Open Group ID was null"))
+                handleJobFailedPermanently(job, name, NullPointerException("Open Group ID was null"))
             } else {
                 val groupChannel = if (!openGroupChannels.containsKey(openGroupId)) {
                     Log.d("OpenGroupDispatcher", "Creating ${openGroupId.hashCode()} channel")
@@ -95,9 +95,16 @@ class JobQueue : JobDelegate {
     }
 
     private fun Job.process(dispatcherName: String) {
-        Log.d(dispatcherName,"processJob: ${javaClass.simpleName}")
+        Log.d(dispatcherName,"processJob: ${javaClass.simpleName} (id: $id)")
         delegate = this@JobQueue
-        execute()
+
+        try {
+            execute(dispatcherName)
+        }
+        catch (e: Exception) {
+            Log.d(dispatcherName, "unhandledJobException: ${javaClass.simpleName} (id: $id)")
+            this@JobQueue.handleJobFailed(this, dispatcherName, e)
+        }
     }
 
     init {
@@ -177,7 +184,7 @@ class JobQueue : JobDelegate {
             return
         }
         if (!pendingJobIds.add(id)) {
-            Log.e("Loki","tried to re-queue pending/in-progress job")
+            Log.e("Loki","tried to re-queue pending/in-progress job (id: $id)")
             return
         }
         queue.trySend(job)
@@ -196,7 +203,7 @@ class JobQueue : JobDelegate {
             }
         }
         pendingJobs.sortedBy { it.id }.forEach { job ->
-            Log.i("Loki", "Resuming pending job of type: ${job::class.simpleName}.")
+            Log.i("Loki", "Resuming pending job of type: ${job::class.simpleName} (id: ${job.id}).")
             queue.trySend(job) // Offer always called on unlimited capacity
         }
     }
@@ -223,21 +230,21 @@ class JobQueue : JobDelegate {
         }
     }
 
-    override fun handleJobSucceeded(job: Job) {
+    override fun handleJobSucceeded(job: Job, dispatcherName: String) {
         val jobId = job.id ?: return
         MessagingModuleConfiguration.shared.storage.markJobAsSucceeded(jobId)
         pendingJobIds.remove(jobId)
     }
 
-    override fun handleJobFailed(job: Job, error: Exception) {
+    override fun handleJobFailed(job: Job, dispatcherName: String, error: Exception) {
         // Canceled
         val storage = MessagingModuleConfiguration.shared.storage
         if (storage.isJobCanceled(job)) {
-            return Log.i("Loki", "${job::class.simpleName} canceled.")
+            return Log.i("Loki", "${job::class.simpleName} canceled (id: ${job.id}).")
         }
         // Message send jobs waiting for the attachment to upload
         if (job is MessageSendJob && error is MessageSendJob.AwaitingAttachmentUploadException) {
-            Log.i("Loki", "Message send job waiting for attachment upload to finish.")
+            Log.i("Loki", "Message send job waiting for attachment upload to finish (id: ${job.id}).")
             return
         }
 
@@ -255,21 +262,22 @@ class JobQueue : JobDelegate {
         job.failureCount += 1
 
         if (job.failureCount >= job.maxFailureCount) {
-            handleJobFailedPermanently(job, error)
+            handleJobFailedPermanently(job, dispatcherName, error)
         } else {
             storage.persistJob(job)
             val retryInterval = getRetryInterval(job)
-            Log.i("Loki", "${job::class.simpleName} failed; scheduling retry (failure count is ${job.failureCount}).")
+            Log.i("Loki", "${job::class.simpleName} failed (id: ${job.id}); scheduling retry (failure count is ${job.failureCount}).")
             timer.schedule(delay = retryInterval) {
-                Log.i("Loki", "Retrying ${job::class.simpleName}.")
+                Log.i("Loki", "Retrying ${job::class.simpleName} (id: ${job.id}).")
                 queue.trySend(job)
             }
         }
     }
 
-    override fun handleJobFailedPermanently(job: Job, error: Exception) {
+    override fun handleJobFailedPermanently(job: Job, dispatcherName: String, error: Exception) {
         val jobId = job.id ?: return
         handleJobFailedPermanently(jobId)
+        Log.d(dispatcherName, "permanentlyFailedJob: ${javaClass.simpleName} (id: ${job.id})")
     }
 
     private fun handleJobFailedPermanently(jobId: String) {

libsession/src/main/java/org/session/libsession/messaging/jobs/MessageReceiveJob.kt

@@ -25,11 +25,11 @@ class MessageReceiveJob(val data: ByteArray, val serverHash: String? = null, val
         private val OPEN_GROUP_ID_KEY = "open_group_id"
     }
 
-    override fun execute() {
-        executeAsync().get()
+    override fun execute(dispatcherName: String) {
+        executeAsync(dispatcherName).get()
     }
 
-    fun executeAsync(): Promise<Unit, Exception> {
+    fun executeAsync(dispatcherName: String): Promise<Unit, Exception> {
         val deferred = deferred<Unit, Exception>()
         try {
             val isRetry: Boolean = failureCount != 0
@@ -39,32 +39,32 @@ class MessageReceiveJob(val data: ByteArray, val serverHash: String? = null, val
             val (message, proto) = MessageReceiver.parse(this.data, this.openGroupMessageServerID, openGroupPublicKey = serverPublicKey)
             message.serverHash = serverHash
             MessageReceiver.handle(message, proto, this.openGroupID)
-            this.handleSuccess()
+            this.handleSuccess(dispatcherName)
             deferred.resolve(Unit)
         } catch (e: Exception) {
             Log.e(TAG, "Couldn't receive message.", e)
             if (e is MessageReceiver.Error && !e.isRetryable) {
                 Log.e("Loki", "Message receive job permanently failed.", e)
-                this.handlePermanentFailure(e)
+                this.handlePermanentFailure(dispatcherName, e)
             } else {
                 Log.e("Loki", "Couldn't receive message.", e)
-                this.handleFailure(e)
+                this.handleFailure(dispatcherName, e)
             }
             deferred.resolve(Unit) // The promise is just used to keep track of when we're done
         }
         return deferred.promise
     }
 
-    private fun handleSuccess() {
-        delegate?.handleJobSucceeded(this)
+    private fun handleSuccess(dispatcherName: String) {
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
-    private fun handlePermanentFailure(e: Exception) {
-        delegate?.handleJobFailedPermanently(this, e)
+    private fun handlePermanentFailure(dispatcherName: String, e: Exception) {
+        delegate?.handleJobFailedPermanently(this, dispatcherName, e)
     }
 
-    private fun handleFailure(e: Exception) {
-        delegate?.handleJobFailed(this, e)
+    private fun handleFailure(dispatcherName: String, e: Exception) {
+        delegate?.handleJobFailed(this, dispatcherName, e)
     }
 
     override fun serialize(): Data {

libsession/src/main/java/org/session/libsession/messaging/jobs/MessageSendJob.kt

@@ -33,7 +33,7 @@ class MessageSendJob(val message: Message, val destination: Destination) : Job {
         private val DESTINATION_KEY = "destination"
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val messageDataProvider = MessagingModuleConfiguration.shared.messageDataProvider
         val message = message as? VisibleMessage
         val storage = MessagingModuleConfiguration.shared.storage
@@ -61,12 +61,12 @@ class MessageSendJob(val message: Message, val destination: Destination) : Job {
                 }
             }
             if (attachmentsToUpload.isNotEmpty()) {
-                this.handleFailure(AwaitingAttachmentUploadException)
+                this.handleFailure(dispatcherName, AwaitingAttachmentUploadException)
                 return
             } // Wait for all attachments to upload before continuing
         }
         val promise = MessageSender.send(this.message, this.destination).success {
-            this.handleSuccess()
+            this.handleSuccess(dispatcherName)
         }.fail { exception ->
             var logStacktrace = true
 
@@ -75,14 +75,14 @@ class MessageSendJob(val message: Message, val destination: Destination) : Job {
                 is HTTP.HTTPRequestFailedException -> {
                     logStacktrace = false
 
-                    if (exception.statusCode == 429) { this.handlePermanentFailure(exception) }
-                    else { this.handleFailure(exception) }
+                    if (exception.statusCode == 429) { this.handlePermanentFailure(dispatcherName, exception) }
+                    else { this.handleFailure(dispatcherName, exception) }
                 }
                 is MessageSender.Error -> {
-                    if (!exception.isRetryable) { this.handlePermanentFailure(exception) }
-                    else { this.handleFailure(exception) }
+                    if (!exception.isRetryable) { this.handlePermanentFailure(dispatcherName, exception) }
+                    else { this.handleFailure(dispatcherName, exception) }
                 }
-                else -> this.handleFailure(exception)
+                else -> this.handleFailure(dispatcherName, exception)
             }
 
             if (logStacktrace) { Log.e(TAG, "Couldn't send message due to error", exception) }
@@ -95,15 +95,15 @@ class MessageSendJob(val message: Message, val destination: Destination) : Job {
         }
     }
 
-    private fun handleSuccess() {
-        delegate?.handleJobSucceeded(this)
+    private fun handleSuccess(dispatcherName: String) {
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
-    private fun handlePermanentFailure(error: Exception) {
-        delegate?.handleJobFailedPermanently(this, error)
+    private fun handlePermanentFailure(dispatcherName: String, error: Exception) {
+        delegate?.handleJobFailedPermanently(this, dispatcherName, error)
     }
 
-    private fun handleFailure(error: Exception) {
+    private fun handleFailure(dispatcherName: String, error: Exception) {
         Log.w(TAG, "Failed to send $message::class.simpleName.")
         val message = message as? VisibleMessage
         if (message != null) {
@@ -111,7 +111,7 @@ class MessageSendJob(val message: Message, val destination: Destination) : Job {
                 return // The message has been deleted
             }
         }
-        delegate?.handleJobFailed(this, error)
+        delegate?.handleJobFailed(this, dispatcherName, error)
     }
 
     override fun serialize(): Data {

libsession/src/main/java/org/session/libsession/messaging/jobs/NotifyPNServerJob.kt

@@ -32,7 +32,7 @@ class NotifyPNServerJob(val message: SnodeMessage) : Job {
         private val MESSAGE_KEY = "message"
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val server = PushNotificationAPI.server
         val parameters = mapOf( "data" to message.data, "send_to" to message.recipient )
         val url = "${server}/notify"
@@ -48,18 +48,18 @@ class NotifyPNServerJob(val message: SnodeMessage) : Job {
                 Log.d("Loki", "Couldn't notify PN server due to error: $exception.")
             }
         }.success {
-            handleSuccess()
+            handleSuccess(dispatcherName)
         }. fail {
-            handleFailure(it)
+            handleFailure(dispatcherName, it)
         }
     }
 
-    private fun handleSuccess() {
-        delegate?.handleJobSucceeded(this)
+    private fun handleSuccess(dispatcherName: String) {
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
-    private fun handleFailure(error: Exception) {
-        delegate?.handleJobFailed(this, error)
+    private fun handleFailure(dispatcherName: String, error: Exception) {
+        delegate?.handleJobFailed(this, dispatcherName, error)
     }
 
     override fun serialize(): Data {

libsession/src/main/java/org/session/libsession/messaging/jobs/OpenGroupDeleteJob.kt

@@ -19,7 +19,7 @@ class OpenGroupDeleteJob(private val messageServerIds: LongArray, private val th
     override var failureCount: Int = 0
     override val maxFailureCount: Int = 1
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val dataProvider = MessagingModuleConfiguration.shared.messageDataProvider
         val numberToDelete = messageServerIds.size
         Log.d(TAG, "Deleting $numberToDelete messages")
@@ -39,10 +39,10 @@ class OpenGroupDeleteJob(private val messageServerIds: LongArray, private val th
             }
 
             Log.d(TAG, "Deleted ${messageIds.first.size + messageIds.second.size} messages successfully")
-            delegate?.handleJobSucceeded(this)
+            delegate?.handleJobSucceeded(this, dispatcherName)
         }
         catch (e: Exception) {
-            delegate?.handleJobFailed(this, e)
+            delegate?.handleJobFailed(this, dispatcherName, e)
         }
     }
 

libsession/src/main/java/org/session/libsession/messaging/jobs/TrimThreadJob.kt

@@ -20,7 +20,7 @@ class TrimThreadJob(val threadId: Long, val openGroupId: String?) : Job {
         const val THREAD_LENGTH_TRIGGER_SIZE = 2000
     }
 
-    override fun execute() {
+    override fun execute(dispatcherName: String) {
         val context = MessagingModuleConfiguration.shared.context
         val trimmingEnabled = TextSecurePreferences.isThreadLengthTrimmingEnabled(context)
         val storage = MessagingModuleConfiguration.shared.storage
@@ -29,7 +29,7 @@ class TrimThreadJob(val threadId: Long, val openGroupId: String?) : Job {
             val oldestMessageTime = System.currentTimeMillis() - TRIM_TIME_LIMIT
             storage.trimThreadBefore(threadId, oldestMessageTime)
         }
-        delegate?.handleJobSucceeded(this)
+        delegate?.handleJobSucceeded(this, dispatcherName)
     }
 
     override fun serialize(): Data {