Guide for AI Coding Agents to Integrate Luciq on Android

⚠️ UNIVERSAL EXECUTION RULES ⚠️

Critical Rules - Apply to ALL Platforms:

NEVER skip WAIT instructions — always get user confirmation before proceeding
NEVER auto-execute optional steps — user must explicitly select them
ALWAYS fetch latest SDK version before integration (DO NOT use placeholders like 1.0.0)
ALL API parameters must be included (can be nil/null) — never omit parameters

Execution Guidelines:

Be specific and concise — save tokens by being to the point
Don't create documentation files — only code files required for integration
Implement mandatory steps sequentially — complete each before moving to the next
Prompt user with current step — describe what's happening, then proceed when done
Only ask for optional steps after mandatory ones — show numbered list for selection
Use numbered lists for all options — makes selection easier (e.g., "Select 1", "Select 2")
Add wrap up step — execute validation only when user selects "Wrap up & validate"
Check documentation first — confirm API availability before getting creative beyond examples

Official Documentation:

Main docs: https://docs.luciq.ai/
Always check official docs when unsure about API signatures or platform specifics

Integration Workflow Overview

MANDATORY STEPS

Step 1: Collect Required Information

1A: Get App Token (MCP or Manual)
1B: Determine Integration Method
1C: Apply Default Config (Inform + Opt-in Customize)

Step 2: Add SDK Dependency (Platform-Specific)

Fetch latest version from GitHub API

Step 3: Initialize the SDK (Platform-Specific)

Default: shake + floatingButton

Step 3B: Configure Network Interception [ANDROID ONLY]

Enable unified network interception in Gradle

DEFAULT CONFIG (Auto-Applied)

Applied automatically (customizable via opt-in):

Network Logging: enabled + common field masking
Screenshot Masking: iOS=maskNothing, Android=all
Symbolication Upload: automatic
User Identification: skip

VERIFICATION

Wrap up & validate: Build → Test → Verify Dashboard

Step 1 — Collect Required Information [MANDATORY]

1A: Get App Token

Check MCP Server First:

IF Luciq MCP server is installed:
  1. Fetch all tokens with app names using MCP tools
  2. Display tokens to user in numbered list with app names
  3. Ask: "Which app token would you like to use?"
  4. WAIT for selection
  5. Store selected token
ELSE:
  1. Display to user: "To integrate Luciq SDK, you'll need your App Token."
  2. Display to user:
     "📍 Find your token: Luciq Dashboard → Settings → SDK Integration"
  3. Display on new line with indentation:
     "   Dashboard URL: https://dashboard.luciq.ai"
  4. Ask: "Please provide your Luciq App Token:"
  5. WAIT for user to provide token
  6. Validate token format (non-empty, alphanumeric)
  7. Store token for later use
END IF

Validation:

Token should be non-empty
Typically 32-40 character hexadecimal string
If invalid format, warn user but proceed

1B: Determine Integration Method

Auto-Detection Logic:

Detect package managers in project:

iOS: Podfile, Cartfile, SPM packages in .xcodeproj, or none → Manual
Android: build.gradle with repositories, pom.xml, or none → Manual

DETECT package managers in project:
  - Count how many are found

IF exactly ONE package manager detected:
  1. Inform user: "Detected [PackageManager], will use this for integration"
  2. Store integration_method
  3. Proceed to Step 2
ELSE IF multiple or zero detected:
  1. Display platform-specific menu (see platform guides)
  2. WAIT for user selection
  3. Store integration_method
  4. Proceed to Step 2
END IF

For Android, detection checks:

build.gradle / build.gradle.kts → Gradle
pom.xml → Maven

Integration Method Menu (if multiple/none detected):

Gradle (Recommended)
Maven

1C: Apply Default Configuration (Inform + Opt-in)

Default configuration is applied automatically. Inform the user:

Display: "Applying default configuration:
  • Invocation: shake + floatingButton
  • Network logging: enabled with common field masking
  • Screenshot masking:
      - iOS: maskNothing (customize per privacy settings)
      - Android: all types (text inputs, labels, media)
  • Symbolication: automatic upload enabled
  • APM (Android): enabled
  • User identification: skip (can add later)

Would you like to customize any of these settings? (yes/no)"

WAIT for response

Store default configuration:

  - invocation_events = [shake, floatingButton]
  - network_logging_enabled = true
  - network_masking_enabled = true
  - predefined_headers_to_mask = ["Authorization", "Cookie", "X-API-Key", "token"]
  - predefined_body_fields_to_mask = ["password", "token", "ssn"]
  - auto_masking_types:
      - iOS: maskNothing (with guidance comments)
      - Android: [textInputs, labels, media]
  - symbolication_upload = enabled
  - repro_steps_config = skip (use defaults)
  - user_identification = skip

FOR ANDROID ONLY:
  - apm_enabled = true
  - Continue to Step 1D (Compose detection)

FOR iOS:
  - Continue to Step 1D (Fastlane detection for dSYM)

If user wants to customize (yes), follow the CUSTOMIZATION LOOP:

1. Display: "Which setting would you like to customize?
     1. Invocation events
     2. Network logging
     3. Screenshot masking
     4. Symbolication upload
     5. User identification

   Enter number:"

2. WAIT for selection

3. Apply the customization (see platform-specific guides for options)

4. Redisplay updated configuration:
   "Updated configuration:
     • Invocation: <current setting>
     • Network logging: <current setting>
     • Screenshot masking: <current setting>
     • Symbolication: <current setting>
     • User identification: <current setting>

   Would you like to customize anything else? (yes/no)"

5. WAIT for response

6. IF yes → Go to step 1
   IF no → Proceed to Step 2

LOOP until user confirms to move on

If user does not want to customize (no): Proceed to Step 2

1D: APM (Application Performance Monitoring) — Android Only

IF config_mode == default:
  apm_enabled is already set to true
  Skip APM prompt, continue to Step 2
ELSE IF config_mode == custom:
  Ask User:
    "Do you want to enable APM (Application Performance Monitoring)?

    APM provides:
      - App launch tracking
      - Network performance monitoring
      - UI hangs detection
      - Screen loading metrics
      - Custom traces & attributes

    Options: yes / no

    WAIT for response"

  Store selection as `apm_enabled` (true/false)
END IF

Step 2 — Add SDK Dependency [MANDATORY - ANDROID]

MUST FETCH LATEST VERSION FIRST:
Fetch latest version from GitHub API: https://api.github.com/repos/luciqai/luciq-android-sdk/releases/latest
Extract version number from the "tag_name" field (e.g., "19.1.0")
Store version for dependency configuration
DO NOT use placeholder versions like "1.0.0" or "latest"

Android Implementation Notes:

If integration_method == gradle, apply Luciq Gradle plugins and dependencies.

Part A: Gradle Plugins (Kotlin DSL / Groovy examples)

Kotlin (project-level build.gradle.kts)

plugins {
    id("ai.luciq.library") version "<FETCHED_VERSION>" apply false
}

Groovy (project-level build.gradle)

buildscript {
    dependencies {
        classpath "ai.luciq.library:luciq-plugin:<FETCHED_VERSION>"
    }
}

App-level (Kotlin DSL)

plugins {
    id("luciq")
    // Add if APM enabled (default):
    // id("luciq-apm")
}

Note: If project uses Firebase Performance Monitoring, ensure Luciq plugins are declared BEFORE Firebase:

plugins {
    id("luciq")
    id("luciq-apm")
    id("com.google.firebase.firebase-perf")  // Firebase AFTER Luciq
}

Part B: Add Dependencies

Kotlin (app-level build.gradle.kts)

dependencies {
    implementation("ai.luciq.library:luciq:<FETCHED_VERSION>")
    // If APM enabled:
    // implementation("ai.luciq.library:luciq-apm:<FETCHED_VERSION>")
}

Groovy (app-level build.gradle)

dependencies {
    implementation 'ai.luciq.library:luciq:<FETCHED_VERSION>'
    // If APM enabled:
    // implementation 'ai.luciq.library:luciq-apm:<FETCHED_VERSION>'
}

Maven (if using Maven)

<dependency>
    <groupId>ai.luciq.library</groupId>
    <artifactId>luciq</artifactId>
    <version><FETCHED_VERSION></version>
</dependency>
<!-- IF apm_enabled -->
<dependency>
    <groupId>ai.luciq.library</groupId>
    <artifactId>luciq-apm</artifactId>
    <version><FETCHED_VERSION></version>
</dependency>

Automatic Permissions: SDK adds these to AndroidManifest.xml automatically:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.WAKE_LOCK"/>

Important: Use exact version in Gradle (do not use + or ranges).

Step 3 — Initialize the SDK [MANDATORY - ANDROID]

IMPORTANT: The SDK initialization MUST be the FIRST code executed in onCreate() (immediately after super.onCreate()). This ensures Luciq captures all app activity from the very start.

Part A: Detect or Create Application Class

Search for classes extending Application and check AndroidManifest.xml for android:name in .

If none found, create MyApplication class and register it in AndroidManifest.xml.

Part B: Initialize Luciq SDK

If NO existing Application class — Create new (Kotlin example):

package com.yourpackage // Use detected package

import android.app.Application
import ai.luciq.library.Luciq
import ai.luciq.library.invocation.LuciqInvocationEvent

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

        // ⚠️ MUST be FIRST - Initialize Luciq immediately after super.onCreate()
        Luciq.Builder(this, "<APP_TOKEN>")
            .setInvocationEvents(<EVENTS>)
            .build()

        // Other initialization code goes AFTER Luciq initialization
        // ...
    }
}

<application
    android:name=".MyApplication"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name">
    <!-- ... activities ... -->
</application>

If existing Application class — Update onCreate():

import ai.luciq.library.Luciq
import ai.luciq.library.invocation.LuciqInvocationEvent

class <ExistingApplicationClass> : Application() {
    override fun onCreate() {
        super.onCreate()

        // ⚠️ MUST be FIRST - Initialize Luciq immediately after super.onCreate()
        Luciq.Builder(this, "<APP_TOKEN>")
            .setInvocationEvents(<EVENTS>)
            .build()

        // Existing initialization code goes AFTER Luciq initialization
        // ...
    }
}

Part C: APM Configuration (If apm_enabled)

In app-level build.gradle(-kts) configure luciq.apm settings. Example (Kotlin DSL):

luciq {
    apm {
        networkEnabled = true
        captureHttpBodyEnabled = true  // default mode
        fragmentSpansEnabled = true
    }
    // Optional: setDebugLogsEnabled(true)
}

Note: APM's network capture is for performance monitoring only. You MUST still add the network interception configuration (Step 3B) for network logs to appear in bug reports.

Invocation Events Syntax

Default invocation events: SHAKE, FLOATING_BUTTON

Kotlin examples:

.setInvocationEvents(
    LuciqInvocationEvent.SHAKE,
    LuciqInvocationEvent.FLOATING_BUTTON
)

// Screenshot only
.setInvocationEvents(LuciqInvocationEvent.SCREENSHOT)

// None (manual only) - omit setInvocationEvents()

Available Events:

LuciqInvocationEvent.SHAKE
LuciqInvocationEvent.SCREENSHOT
LuciqInvocationEvent.FLOATING_BUTTON
LuciqInvocationEvent.NONE

Step 3B — Configure Network Interception [MANDATORY]

The Luciq Gradle Plugin automatically instruments OkHttp and UrlConnection networking libraries. Minimum SDK version for unified interception: 19.0.0+

Configuration Settings (defaults shown)

Setting

Default

networkInterception.enabled

false

okHttp.enabled

true

urlConnection.enabled

true

okHttp.legacyApmInterceptionEnabled

true

urlConnection.legacyInterceptionEnabled

true

Enable Network Interception (Gradle plugin examples)

Kotlin DSL (build.gradle.kts):

luciq {
    networkInterception {
        enabled = true
        okHttp { config ->
            config.enabled = true
            config.legacyApmInterceptionEnabled = false
        }
        urlConnection { config ->
            config.enabled = true
            config.legacyInterceptionEnabled = false
        }
    }
}

Groovy (build.gradle):

luciq {
    networkInterception {
        enabled = true
        okHttp { config ->
            config.enabled = true
            config.legacyApmInterceptionEnabled = false
        }
        urlConnection { config ->
            config.enabled = true
            config.legacyInterceptionEnabled = false
        }
    }
}

Note: Disabling legacy interceptors now ensures smoother future upgrades.

Selective Library Instrumentation (Optional)

luciq {
    networkInterception {
        enabled = true
        okHttp { config -> config.enabled = false }
        urlConnection { config -> config.enabled = false }
    }
}

Part C: Mask Sensitive Data (Application class, after Luciq.Builder().build())

Use Luciq.setNetworkLogListener to mask headers and recursively mask JSON body fields.

Kotlin example (place in Application class after initialization):

import ai.luciq.library.Luciq
import org.json.JSONObject
import org.json.JSONArray

val headersToMask = listOf("Authorization", "Cookie", "X-API-Key", "token")
val bodyFieldsToMask = setOf("password", "token", "ssn")

Luciq.setNetworkLogListener { snapshot ->
    headersToMask.forEach { header ->
        if (snapshot.requestHeaders.containsKey(header)) {
            snapshot.requestHeaders[header] = "*****"
        }
        snapshot.responseHeaders?.let { headers ->
            if (headers.containsKey(header)) {
                headers[header] = "*****"
            }
        }
    }

    snapshot.requestBody?.let { body ->
        snapshot.requestBody = maskJsonFields(body, bodyFieldsToMask)
    }

    snapshot.responseBody?.let { body ->
        snapshot.responseBody = maskJsonFields(body, bodyFieldsToMask)
    }

    snapshot  // Return modified snapshot, or null to exclude log entirely
}

// Recursive helper functions (as provided in examples)
private fun maskJsonFields(jsonString: String, fieldsToMask: Set<String>): String { ... }
private fun maskJsonObject(obj: JSONObject, fieldsToMask: Set<String>): JSONObject { ... }
private fun maskJsonArray(arr: JSONArray, fieldsToMask: Set<String>): JSONArray { ... }

Key Points:

Mask headers with "*****" (preserves header presence)
Body fields: Recursive masking at any depth using Set for O(1) lookup
Return null to exclude a log entirely

Optional Step 1 — Mask Repro Step Screenshots (Android)

Minimum SDK Version: 11.13.0

If config_mode == default:

Luciq.setAutoMaskScreenshotsTypes(
    MaskingType.TEXT_INPUTS,
    MaskingType.LABELS,
    MaskingType.MEDIA
)

Custom mode examples:

// Text inputs only
Luciq.setAutoMaskScreenshotsTypes(MaskingType.TEXT_INPUTS)

// Disable auto masking
Luciq.setAutoMaskScreenshotsTypes(MaskingType.MASK_NOTHING)

Additional privacy controls:

Luciq.addPrivateViews(view1, view2, view3)
Luciq.removePrivateViews(view1, view2, view3)

Available Masking Types:

MaskingType.TEXT_INPUTS
MaskingType.LABELS
MaskingType.MEDIA
MaskingType.MASK_NOTHING

Notes:

Private Views API takes precedence over Auto Masking
Works with Bug Reporting, Crash Reporting, and Session Replay
Screenshots are disabled by default for Crash Reporting

Optional Step 2 — Configure Repro Steps Mode (Android)

Use ReproConfigurations.Builder to set IssueType modes:

Examples:

val configurations = ReproConfigurations.Builder()
    .setIssueMode(IssueType.Bug, ReproMode.EnableWithScreenshots)
    .setIssueMode(IssueType.SessionReplay, ReproMode.EnableWithScreenshots)
    .setIssueMode(IssueType.Crash, ReproMode.EnableWithNoScreenshots)
    .build()

Luciq.setReproConfigurations(configurations)

IssueType options:

IssueType.Bug
IssueType.Crash
IssueType.SessionReplay
IssueType.All

Key Points:

Selected products → ReproMode.EnableWithScreenshots
Non-selected → ReproMode.EnableWithNoScreenshots

Optional Step 3 — Add User Identification (Android)

Purpose: Link bug reports to specific user accounts.

Display options:

Using email
Using user ID
Using both email and ID
Skip (no user identification)

If user selects identification, search for login flows and add identify call AFTER successful auth and BEFORE navigation.

API Signature:

Luciq.identifyUser(
    name: String?,   // can be null
    email: String?,  // can be null
    id: String?      // can be null
)

⚠️ CRITICAL: At least email OR id must be non-null. All null throws error.

Examples:

Email only: Luciq.identifyUser(user.name, user.email, null)
ID only: Luciq.identifyUser(user.name, null, user.id)
Both: Luciq.identifyUser(user.name, user.email, user.id)

Additional user data:

Luciq.setUserData("Premium user, subscription: pro")

Logout flow:

Luciq.logoutUser()
// Then clear user session/data

Placement rules:

Identify AFTER authentication succeeds
Add logout BEFORE clearing session data

Optional Step 4 — Upload Mapping Files (Android)

This is configured automatically in default mode. Purpose: Upload ProGuard/R8 mapping files for crash symbolication.

Part A: Create upload_mapping.sh (project root)

#!/bin/bash
echo "Luciq mapping files uploader"

APP_TOKEN="$1"
VERSION_CODE="$2"
VERSION_NAME="$3"
PATH_TO_MAPPING_FILE="$4"
VERSION='{"code":"'"$VERSION_CODE"'","name":"'"$VERSION_NAME"'"}'

if [ ! -f "$PATH_TO_MAPPING_FILE" ]; then
    echo "Mapping file not found!"
    exit 0
fi

echo "Mapping file found! Uploading..."

ENDPOINT="https://api.luciq.ai/api/sdk/v3/symbols_files"
STATUS=$(curl "${ENDPOINT}" --write-out %{http_code} --silent --output /dev/null \
    -F os=android \
    -F app_version="${VERSION}" \
    -F symbols_file=@"${PATH_TO_MAPPING_FILE}" \
    -F application_token="${APP_TOKEN}")

if [ $STATUS -ne 200 ]; then
  echo "Error while uploading mapping files"
  exit 0
fi

echo "Success! Your mapping files got uploaded successfully"

Part B: Add Gradle Task (examples)

Kotlin DSL (build.gradle.kts)

tasks.register<Exec>("uploadMappingFiles") {
    android.applicationVariants.all {
        if (buildType.name == "release" && mappingFileProvider.isPresent) {
            val mappingFile = mappingFileProvider.get().singleFile
            if (mappingFile.exists()) {
                commandLine(
                    "sh",
                    "../upload_mapping.sh",
                    "<APP_TOKEN>",
                    versionCode.toString(),
                    versionName,
                    mappingFile.absolutePath
                )
            }
        }
    }
}

Groovy (build.gradle)

task uploadMappingFiles(type: Exec) {
    android.applicationVariants.all { variant ->
        if (variant.buildType.name == "release" && variant.mappingFile != null && variant.mappingFile.exists()) {
            commandLine 'sh', '../upload_mapping.sh',
                '<APP_TOKEN>',
                variant.versionCode,
                variant.versionName,
                variant.mappingFile
        }
    }
}

Part C: Run After Release Build

./gradlew assembleRelease
./gradlew :app:uploadMappingFiles

Alternative: Manual dashboard upload via Luciq dashboard Settings.

Step 4 — Verification & Testing (Wrap up & validate) [USER-INITIATED ONLY]

⚠️ CRITICAL: This step is ONLY executed when the user explicitly selects "Wrap up & validate" from the optional steps menu. Do NOT run automatically after mandatory steps complete.

After mandatory steps complete, display the summary and menu:

✅ Luciq SDK integration complete!

Platform: Android
SDK Version: <version>
Integration Method: <Gradle/Maven>

Configuration:
  • App Token: <first 8 chars>...
  • Invocation Events: <configured events>
  • Network Logging: <enabled/disabled>
  • Network Masking:
      - Headers: <list or none>
      - Body Fields: <list or none>
  • Screenshot Masking: <types or none>
  • Symbolication Upload: <automatic/manual/skip>
  • User Identification: <configured or not configured>

Next Steps - Select an option:
1. Configure optional features
2. Wrap up & validate

WAIT for user selection. Do NOT proceed to build verification unless user selects option 2.

1. Build Verification (ONLY WHEN USER REQUESTS)

Execute platform-specific build command:

Android: ./gradlew assembleDebug

Expected Result: BUILD SUCCEEDED with no errors

Common Build Errors & Solutions:

"compileSdkVersion < 29" → set compileSdkVersion to 29+
"Unresolved reference: Luciq" → missing dependency, sync gradle and verify version
"Duplicate class" → dependency conflict; run ./gradlew dependencies to inspect

2. Runtime Testing (MANUAL)

Steps to test:

Build and run the app on emulator/device:
```
./gradlew installDebug
```
Trigger Luciq using configured invocation:
- Shake: Shake device/emulator
- Screenshot: Power + Volume Down
- Floating Button: Tap overlay
Verify Luciq UI appears
Fill out and submit a test bug report
Check Luciq dashboard at https://dashboard.luciq.ai — verify report, user identification, and network logs

3. Final Summary (Display after build success)

✅ Luciq SDK successfully integrated and validated!

Platform: Android
SDK Version: <version>
Integration Method: <Gradle/Maven>

Configuration:
  • App Token: <first 8 chars>...
  • Invocation Events: <configured events>
  • Network Logging: <enabled/disabled>
  • Network Masking:
      - Headers: <list or none>
      - Body Fields: <list or none>
  • Screenshot Masking: <types or none>
  • Symbolication Upload: <automatic/manual/skip>
  • User Identification: <configured or not configured>

Build Status: ✅ SUCCEEDED

Next Steps:
  • ✅ Build completed successfully
  • Run the app and test SDK invocation
  • Submit a test report
  • Verify report in Luciq dashboard

Integration Complete - Ready for Testing!

Error Handling & Troubleshooting

Common Issues Across Platforms

SDK Not Initializing

Verify token is correct
Check initialization code placement (usually in app entry point)
Ensure import statement is correct

Network Logging Not Working

Verify masking code placed AFTER SDK initialization
Check that network interceptor is properly configured
Ensure app has network permissions

User Identification Not Showing

Verify identifyUser called after successful login
Check that logout is called on all logout paths
Ensure parameters are not all null

Reports Not Appearing in Dashboard

Verify device/simulator has internet connection
Check app token is correct
Wait a few minutes for sync
Check dashboard filters

Android-Specific Troubleshooting

Issue: "compileSdkVersion must be >= 29"

android {
    compileSdkVersion = 34  // or higher
}

Issue: Network logs not appearing

Fix: Enable unified network interception in luciq { networkInterception { enabled = true } }

Issue: Application class not registered

Fix: Add android:name=".MyApplication" to tag in manifest

Issue: User identification error

Fix: Ensure at least email OR id is non-null (not both null)

Issue: Screenshots not masking

Fix: Use setAutoMaskScreenshotsTypes(MaskingType.TEXT_INPUTS, MaskingType.LABELS)

Quick Reference (Kotlin)

// IMPORTS
import ai.luciq.library.Luciq
import ai.luciq.library.invocation.LuciqInvocationEvent
import ai.luciq.library.MaskingType

// INITIALIZATION (in Application class - default: shake + floatingButton)
Luciq.Builder(this, "APP_TOKEN")
    .setInvocationEvents(LuciqInvocationEvent.SHAKE, LuciqInvocationEvent.FLOATING_BUTTON)
    .build()

// NETWORK INTERCEPTION (in build.gradle.kts - MANDATORY)
luciq {
    networkInterception {
        enabled = true
        okHttp { config ->
            config.legacyApmInterceptionEnabled = false
        }
        urlConnection { config ->
            config.legacyInterceptionEnabled = false
        }
    }
}

// NETWORK LOG MASKING (in Application class after Luciq.Builder().build())
Luciq.setNetworkLogListener { snapshot ->
    listOf("Authorization", "Cookie").forEach { header ->
        if (snapshot.requestHeaders.containsKey(header)) {
            snapshot.requestHeaders[header] = "*****"
        }
    }
    snapshot  // Return modified snapshot, or null to exclude
}

// USER IDENTIFICATION
Luciq.identifyUser(user.name, user.email, user.id)  // At least email or id non-null

// USER DATA
Luciq.setUserData("Additional context")

// LOGOUT
Luciq.logoutUser()

// SCREENSHOT AUTO MASKING
Luciq.setAutoMaskScreenshotsTypes(MaskingType.TEXT_INPUTS, MaskingType.LABELS)

// PRIVATE VIEWS
Luciq.addPrivateViews(view1, view2)

Java Equivalents

All Kotlin examples have straightforward Java equivalents:

val → final
Lambda { } → Anonymous inner class
?.let → null check with if
Extension functions → Static utility methods

Refer to official docs for Java examples if needed:

PreviousUpdating the SDK NextSet up Bug Reporting

Last updated 1 day ago