Some classes to help debugging LifeCycle and RxJava subscriptions.

LifecycleLogger.kt

import android.util.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent

class LifecycleLogger(private val lifecycleName: String) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() = logLifecycleEvent(Lifecycle.Event.ON_CREATE.name)

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() = logLifecycleEvent(Lifecycle.Event.ON_START.name)

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun onResume() = logLifecycleEvent(Lifecycle.Event.ON_RESUME.name)

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun onPause() = logLifecycleEvent(Lifecycle.Event.ON_PAUSE.name)

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() = logLifecycleEvent(Lifecycle.Event.ON_DESTROY.name)

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() = logLifecycleEvent(Lifecycle.Event.ON_STOP.name)

    private fun logLifecycleEvent(eventName: String) = Log.d(LOG_TAG, "Event on \"$lifecycleName\": $eventName")

    companion object {
        private const val LOG_TAG = "LifecycleLogger"
    }
}

LoggerTransformer.kt

import android.util.Log
import io.reactivex.Observable
import io.reactivex.ObservableSource
import io.reactivex.ObservableTransformer
import io.reactivex.Single
import io.reactivex.SingleSource
import io.reactivex.SingleTransformer

class LoggerTransformer<U>(private val streamName: String) : SingleTransformer<U, U>, ObservableTransformer<U, U> {
    override fun apply(upstream: Observable<U>): ObservableSource<U> {
        return upstream
            .doOnError { logError(it) }
            .doOnSubscribe { logSubscribe() }
            .doOnDispose { logDispose() }
            .doOnTerminate { logTerminate() }
    }

    override fun apply(upstream: Single<U>): SingleSource<U> {
        return upstream
            .doOnError { logError(it) }
            .doOnSubscribe { logSubscribe() }
            .doOnDispose { logDispose() }
            .doOnTerminate { logTerminate() }
    }

    private fun logTerminate() {
        Log.d(LOG_TAG, "$streamName was terminated.")
    }

    private fun logError(error: Throwable) {
        Log.d(LOG_TAG, "Error on $streamName: ${error.message}")
    }

    private fun logDispose() {
        Log.d(LOG_TAG, "$streamName was disposed.")
    }

    private fun logSubscribe() {
        Log.d(LOG_TAG, "Subscribed on $streamName.")
    }

    companion object {
        private const val LOG_TAG = "StreamLogger"
    }
}