Android SDK

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://center.abrova.ir/api/packages/abrova/maven") }
    }
}

dependencies {
    implementation("ir.abrova.trace:abrova-trace-android-sdk:0.2.3")
}

import android.app.Application
import ir.abrova.trace.sdk.AbrovaTrace
import ir.abrova.trace.sdk.AbrovaTraceConfig

class MyApp : Application() {

    override fun onCreate() {
        super.onCreate()

        val config = AbrovaTraceConfig.Builder("ab_live_YOUR_API_KEY")
            .environment(if (BuildConfig.DEBUG) "development" else "production")
            .release(BuildConfig.VERSION_NAME)
            .debug(BuildConfig.DEBUG)
            .captureUncaughtExceptions(true)
            .captureSignalCrashes(true)
            .captureAnr(true)
            .anrTimeoutMs(5000L)
            .build()

        AbrovaTrace.init(this, config)
    }

    override fun onTerminate() {
        AbrovaTrace.close()
        super.onTerminate()
    }
}

class MainActivity : AppCompatActivity() {
    override fun onDestroy() {
        if (isFinishing) {
            AbrovaTrace.close()  // Flush logs, stop the ANR watchdog
        }
        super.onDestroy()
    }
}

try {
    someRiskyOperation()
} catch (e: Exception) {
    AbrovaTrace.captureException(e)
}

AbrovaTrace.captureException(
    throwable = exception,
    message = "Failed to load user profile",
    extra = mapOf("user_id" to userId, "screen" to "ProfileActivity"),
    tags = mapOf("feature" to "user_profile")
)

import ir.abrova.trace.sdk.models.MessageLevel

// Info message
AbrovaTrace.captureMessage("User completed onboarding", MessageLevel.INFO)

// Warning message
AbrovaTrace.captureMessage("API rate limit approaching", MessageLevel.WARNING)

// Error message with extra data
AbrovaTrace.captureMessage(
    message = "Payment failed",
    level = MessageLevel.ERROR,
    extra = mapOf("amount" to 99.99)
)

import ir.abrova.trace.sdk.models.BreadcrumbType

// User action
AbrovaTrace.addUserBreadcrumb("Added item to cart", mapOf("product_id" to "abc"))

// Navigation
AbrovaTrace.addNavigationBreadcrumb(from = "MainActivity", to = "ProductDetailActivity")

// HTTP request
AbrovaTrace.addHttpBreadcrumb(
    method = "POST",
    url = "https://api.example.com/orders",
    statusCode = 201,
    duration = 342L
)

// Custom breadcrumb
AbrovaTrace.addBreadcrumb("Order placed", BreadcrumbType.INFO, mapOf(
    "order_id" to "12345",
    "total" to 99.99
))

import ir.abrova.trace.sdk.network.AbrovaTraceInterceptor
import okhttp3.OkHttpClient

val client = OkHttpClient.Builder()
    .addInterceptor(AbrovaTraceInterceptor())
    .build()

import ir.abrova.trace.sdk.network.AbrovaTraceInterceptor
import ir.abrova.trace.sdk.network.AbrovaTraceErrorInterceptor
import okhttp3.OkHttpClient

val client = OkHttpClient.Builder()
    .addInterceptor(AbrovaTraceInterceptor())       // Adds breadcrumbs
    .addInterceptor(AbrovaTraceErrorInterceptor())  // Captures HTTP errors
    .build()

import ir.abrova.trace.sdk.network.AbrovaTraceInterceptor
import ir.abrova.trace.sdk.network.AbrovaTracePerformanceInterceptor
import okhttp3.OkHttpClient
import okhttp3.Request

val client = OkHttpClient.Builder()
    .addInterceptor(AbrovaTraceInterceptor())              // Breadcrumbs
    .addInterceptor(AbrovaTracePerformanceInterceptor())   // APM tracking
    .build()

// All API calls are automatically tracked!
val request = Request.Builder()
    .url("https://api.example.com/users")
    .build()

client.newCall(request).execute().use { response ->
    // Duration, status code, and errors are automatically reported
    val users = response.body?.string()
}

import ir.abrova.trace.sdk.network.AbrovaTraceInterceptor
import ir.abrova.trace.sdk.network.AbrovaTracePerformanceInterceptor
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(AbrovaTraceInterceptor())
    .addInterceptor(AbrovaTracePerformanceInterceptor())
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(okHttpClient)
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val api = retrofit.create(MyApiService::class.java)
// All API calls through this Retrofit instance are automatically tracked

import ir.abrova.trace.sdk.AbrovaTrace

val result = AbrovaTrace.trackOperation("load_user_profile") {
    val user = fetchUserFromApi()
    cacheUserLocally(user)
    user
}

import ir.abrova.trace.sdk.models.PerformanceSpan

// HTTP request span
AbrovaTrace.reportPerformanceSpan(
    PerformanceSpan.fromHttpRequest(
        method = "GET",
        url = "https://api.example.com/products",
        statusCode = 200,
        durationMs = 245L,
        startTime = System.currentTimeMillis() - 245
    )
)

// Database query span
AbrovaTrace.reportPerformanceSpan(
    PerformanceSpan.forDbQuery(
        queryType = "SELECT",
        tableName = "products",
        durationMs = 15L,
        startTime = System.currentTimeMillis() - 15,
        rowsAffected = 50
    )
)

// Custom operation span
AbrovaTrace.reportPerformanceSpan(
    PerformanceSpan.custom(
        operation = "image_processing",
        durationMs = 1250L,
        startTime = System.currentTimeMillis() - 1250,
        tags = mapOf("format" to "png")
    )
)

// Enable logging after AbrovaTrace.init()
AbrovaTrace.enableLogging(sourceId = "my-android-app")

AbrovaTrace.info("User login successful", mapOf("user_id" to "user_123"))

val config = AbrovaTraceConfig.Builder("ab_live_YOUR_API_KEY")
    .environment("production")        // Environment name
    .release("1.0.0")                 // App version
    .debug(false)                     // Enable debug logging
    .enabled(true)                    // Enable/disable SDK
    .sampleRate(1.0f)                 // Error sample rate (0.0 - 1.0)
    .maxBreadcrumbs(20)               // Max breadcrumbs to keep
    .httpTimeout(30)                  // HTTP request timeout (seconds)
    .enableOfflineStorage(true)       // Keep unsent errors on the device while offline
    .captureUncaughtExceptions(true)  // Catch uncaught exceptions
    .captureSignalCrashes(true)       // Detect native signal crashes
    .captureAnr(true)                 // Detect ANR issues
    .anrTimeoutMs(5000L)              // ANR detection timeout
    .apiUrl("https://trace.abrova.ir") // Server URL (self-hosted override)
    .build()

-keep class ir.abrova.trace.sdk.** { *; }
-keepattributes SourceFile,LineNumberTable
-keepattributes *Annotation*

// Set individual extras
AbrovaTrace.setExtra("organizationId", "org-123")
AbrovaTrace.setExtra("feature", "checkout-v2")

// Set multiple at once
AbrovaTrace.setExtras(mapOf(
    "organizationId" to "org-123",
    "feature" to "checkout-v2",
    "experiment" to "new-flow"
))

// Clear when no longer needed (e.g. on logout)
AbrovaTrace.clearExtras()

AbrovaTrace.setTag("team", "payments")
AbrovaTrace.setTag("region", "us-east")

AbrovaTrace.setTags(mapOf("team" to "payments", "version" to "2.1"))

AbrovaTrace.clearTags()

import android.app.Application
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import ir.abrova.trace.sdk.AbrovaTrace
import ir.abrova.trace.sdk.AbrovaTraceConfig
import ir.abrova.trace.sdk.models.MessageLevel
import ir.abrova.trace.sdk.network.AbrovaTraceInterceptor
import okhttp3.OkHttpClient

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()

        val config = AbrovaTraceConfig.Builder("ab_live_YOUR_API_KEY")
            .environment(if (BuildConfig.DEBUG) "development" else "production")
            .release(BuildConfig.VERSION_NAME)
            .debug(BuildConfig.DEBUG)
            .captureUncaughtExceptions(true)
            .captureSignalCrashes(true)
            .captureAnr(true)
            .anrTimeoutMs(5000L)
            .maxBreadcrumbs(20)
            .enableOfflineStorage(true)
            .build()

        AbrovaTrace.init(this, config)
    }

    override fun onTerminate() {
        AbrovaTrace.close()
        super.onTerminate()
    }
}

class MainActivity : AppCompatActivity() {

    private val httpClient = OkHttpClient.Builder()
        .addInterceptor(AbrovaTraceInterceptor())
        .build()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        AbrovaTrace.setUserId("user_123")
        AbrovaTrace.addUserBreadcrumb("Viewed home screen")
    }

    private fun handlePurchase() {
        try {
            processPurchase()
            AbrovaTrace.captureMessage(
                message = "Purchase successful",
                level = MessageLevel.INFO,
                extra = mapOf("amount" to 99.99)
            )
        } catch (e: Exception) {
            AbrovaTrace.captureException(
                throwable = e,
                message = "Purchase failed",
                extra = mapOf("user_id" to "user_123", "screen" to "MainActivity")
            )
        }
    }

    override fun onDestroy() {
        if (isFinishing) {
            AbrovaTrace.close()
        }
        super.onDestroy()
    }

    private fun processPurchase() { /* ... */ }
}