The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
feat: updated docs for android symbolication (#226)
narrow-adventure6b45155fcc09
diff --git a/README.md b/README.mdindex 9edb5f8e..0983ceec 100644--- a/README.md+++ b/README.md@@ -64,15 +64,15 @@ The [CLI](./cli) is designed for agents first: JSON when piped, tables on a TTY,The skills are plain Markdown in [`skills/`](./skills), in the same MIT-licensed repo. No marketplace, no lock-in. [Learn more →](https://tracewayapp.com/product/agent-skills)-## JavaScript Symbolication+## Symbolication-`app.min.js:1:63` tells you nothing. Traceway resolves minified production errors back to the original file, line, and function the moment they arrive.+`app.min.js:1:63` tells you nothing. Traceway resolves minified production errors back to the original file, line, and function the moment they arrive, and the same engine does it for stripped native crashes: iOS and Swift against the build's dSYM, Android against its R8 `mapping.txt`, Dart and Flutter against their obfuscation map.-The symbolicator is pure Go and built to keep up with ingest. Each source map compiles once into a binary `.tw` file and is memory-mapped from disk: under a microsecond to open a compiled map, p99 lookup under a millisecond on a cold cache, zero maps re-parsed after a restart. The corpus is a disk budget, not a RAM budget.+The symbolicator is pure Go and built to keep up with ingest. Every debug artifact (a source map, a dSYM, an R8 mapping) compiles once into a binary `.tw` file and is memory-mapped from disk: under a microsecond to open a compiled map, p99 lookup under a millisecond on a cold cache, zero maps re-parsed after a restart. The corpus is a disk budget, not a RAM budget.The same engine ships as a standalone [OpenTelemetry Collector processor](./backend/app/symbolicator/otelprocessor), drop-in compatible with Honeycomb's `source_map_symbolicator`: same component type, same attribute contract, same config keys. Use it in your own pipeline, with or without Traceway behind it.-Upload maps from CI with `npx traceway-sourcemaps --directory ./dist`. Benchmarks live in [`benchmarks/`](./benchmarks); run them on your fork. [Learn more →](https://tracewayapp.com/product/javascript-symbolication)+Upload source maps from CI with `npx traceway-sourcemaps --directory ./dist`; dSYMs and R8 mappings post to the same endpoint. Benchmarks live in [`benchmarks/`](./benchmarks); run them on your fork. [Learn more →](https://tracewayapp.com/product/symbolication)## Why Tracewaydiff --git a/docs/pages/client/android/index.mdx b/docs/pages/client/android/index.mdxindex 2492855b..0e2078cb 100644--- a/docs/pages/client/android/index.mdx+++ b/docs/pages/client/android/index.mdx@@ -8,7 +8,7 @@ Add the dependency to your app module's `build.gradle.kts`:```kotlindependencies {- implementation("com.tracewayapp:traceway:1.0.0")+ implementation("com.tracewayapp:traceway:1.0.1")}```diff --git a/docs/pages/symbolicator/android.mdx b/docs/pages/symbolicator/android.mdxindex 9421347b..6345e08e 100644--- a/docs/pages/symbolicator/android.mdx+++ b/docs/pages/symbolicator/android.mdx@@ -18,7 +18,7 @@ com.example.app.PaymentDeclinedException: card declined for $30.59at com.example.app.MainActivity.crashKotlin(MainActivity.kt:33)```-This page covers how to upload `mapping.txt` with the Gradle plugin, the upload API, how a trace is recognized and resolved, and how to migrate an app off Honeycomb. For when symbolication runs, the cache, and the `.tw` format, see [Architecture](/symbolicator).+This page covers how to upload `mapping.txt` with the Gradle plugin, the upload API, how a trace is recognized and resolved, the compact `.tw` artifact each mapping compiles into, and how to migrate an app off Honeycomb. For the shared cache model and when symbolication runs, see [Architecture](/symbolicator).## R8: what `mapping.txt` says@@ -43,7 +43,7 @@ Then apply it to your app module:```kotlinplugins {- id("com.tracewayapp.symbols") version "0.0.1"+ id("com.tracewayapp.symbols") version "1.0.1"}android {@@ -110,6 +110,17 @@ androidmappings/{projectId}/{proguardUuid}.txt # R8 mapping, by build UUIDA maximum of 50 frames are emitted, inline expansions included. A frame with no match keeps its raw form, so a trace is never worse than it arrived.+## The flat format++R8 `mapping.txt` is plain text and cheap to parse, but the engine never retraces against the text twice. On the first crash for a build, the mapping compiles once into the same compact [`.tw`](/symbolicator#the-tw-resolver-format) flat artifact used for JavaScript source maps and native dSYM/DWARF symbols, and that artifact is what every later lookup uses.++Where the other languages' `.tw` files map an address (a bundle position, a program counter) to a span of frames, the R8 `.tw` maps an obfuscated **(class, method, line)** to its original frames. It holds two sorted tables, both binary-searchable, with every class, method, and file name interned once:++- A **class table**, sorted by obfuscated class name, mapping each token to its original fully qualified name and source file.+- A **member table**, sorted within each class by obfuscated method name. Each record carries the original class, method, and file, plus the obfuscated and original line ranges. One obfuscated method can map to several records, because R8 inlines small methods into their callers, so a single frame resolves to a chain of source frames innermost first, with the obfuscated line selecting which records apply. Synthesized members are flagged and skipped.++A lookup binary-searches the class table, then the member table, then filters by line range, so resolution stays a handful of comparisons no matter how large the mapping is. The artifact is read in place: in disk-cache mode a crash retraces straight off the memory-mapped `.tw` with the name tables living in the OS page cache, while in memory mode the parsed mapping is held on the heap. Either way the compiled form rides the [same cache tiers](/symbolicator#cache-tiers) as every other language (in-memory LRU, the local `.tw` disk cache, and object storage) and rebuilds automatically when the format version is bumped. The throughput and memory trade between the two modes is measured on [Performance](/symbolicator/performance).+## Migrating from HoneycombHoneycomb symbolicates Android in its OpenTelemetry Collector, keying ProGuard mappings by the `app.debug.proguard_uuid` resource attribute and storing them as `<uuid>.txt`. Traceway reads that **same** attribute and `<uuid>.txt` naming on the OTLP path, so a migrating app does not change its instrumentation.@@ -124,7 +135,8 @@ Symbolication then happens in Traceway, in the collector processor or in the bac## Related pages+- [Android SDK](/client/android): capturing errors and crashes from an Android app- [Architecture](/symbolicator): when symbolication runs, the cache tiers, and the `.tw` format- [iOS](/symbolicator/ios) and [Dart](/symbolicator/dart): the flat-DWARF approach for native symbols-- [Performance](/symbolicator/performance): cache sizing and failure handling+- [Performance](/symbolicator/performance): the Android benchmark, cache sizing, and failure handling```diff --git a/docs/pages/symbolicator/index.mdx b/docs/pages/symbolicator/index.mdxindex 0fcb5b06..76afa6ef 100644--- a/docs/pages/symbolicator/index.mdx+++ b/docs/pages/symbolicator/index.mdx@@ -39,7 +39,7 @@ The structure is the same regardless of where the debug info came from:Because the ranges are sorted, a lookup is a single binary search. Because the layout is fixed and little-endian, opening a `.tw` validates its structure and then reads straight from the mapped pages, with no copying or decoding, and the OS page cache shares those pages across every process that maps the same file. Compiling the resolver (parsing the debug info, computing every range, interning every name) runs once at build time; opening the compiled result skips all of it.-A `.tw` is a cache artifact, never the source of truth. It's versioned by a single integer with no migration path: bump the version and every existing file fails validation and is lazily rebuilt from its original debug info. Each language has its own `.tw` encoding tuned to its debug format; the per-language specifics are on the [JavaScript](/symbolicator/javascript), [Dart](/symbolicator/dart), and [iOS](/symbolicator/ios) pages.+A `.tw` is a cache artifact, never the source of truth. It's versioned by a single integer with no migration path: bump the version and every existing file fails validation and is lazily rebuilt from its original debug info. Each language has its own `.tw` encoding tuned to its debug format; the per-language specifics are on the [JavaScript](/symbolicator/javascript), [Dart](/symbolicator/dart), [iOS](/symbolicator/ios), and [Android](/symbolicator/android) pages.## Cache tiers@@ -68,6 +68,7 @@ Raw artifacts are fetched on demand and never kept on local disk by the engine.- **[JavaScript](/symbolicator/javascript)** — source maps and bundle scope analysis.- **[Dart](/symbolicator/dart)** — stripped Flutter traces and DWARF.- **[iOS](/symbolicator/ios)** — stripped Swift/ObjC release crashes and dSYM/DWARF.+- **[Android](/symbolicator/android)** — obfuscated R8 release crashes and `mapping.txt` retrace.- **[Performance](/symbolicator/performance)** — memory vs disk cache, sizing, benchmarks, and the metrics to watch.- **[OpenTelemetry](/symbolicator/opentelemetry)** — running the engine as a collector processor.- **[Library](/symbolicator/library)** — calling the engine from your own Go code.diff --git a/docs/pages/symbolicator/performance.mdx b/docs/pages/symbolicator/performance.mdxindex d2c318fb..7b1a886b 100644--- a/docs/pages/symbolicator/performance.mdx+++ b/docs/pages/symbolicator/performance.mdx@@ -53,7 +53,25 @@ Dart, [full run](https://github.com/tracewayapp/traceway/actions/runs/2752248509Dart trades a little differently. The ELF symbol files are large, so memory mode wins the hot path outright (28,605 stacks/s, 5.5ms p99) when everything fits. But watch the RSS column: disk mode stays pinned between 103 and 138 MB across every scenario, including `oom`, while memory mode climbs to 2,165 MB. Disk mode pays a steadier ~400ms tail for mmap page-ins and buys flat, predictable memory in return.-The one-sentence summary across both languages: if your corpus fits in RAM and stays there, memory mode is fastest; if it doesn't, or you can't promise it always will, disk mode is the one that keeps running.+Android, from the same [`benchmarks/processor`](https://github.com/tracewayapp/traceway/tree/main/benchmarks/processor) harness. Honeycomb is back in the table, because its logs-only `proguard_symbolicator` does symbolicate Android:++| impl | scenario | max stacks/s | p99 ms (max) | peak RSS (MB) | avg CPU% | symb% | outcome |+|------|----------|-------------:|-------------:|--------------:|---------:|------:|---------|+| honeycomb-android | churn | 18769 | 314.653 | 2319 | 286 | 100 | survived |+| honeycomb-android | hot | 20394 | 316.124 | 2331 | 203 | 100 | survived |+| honeycomb-android | oom | 1692 | 442.011 | 5575 | 151 | 100 | survived |+| traceway-android-disk | churn | 37217 | 339.465 | 90 | 318 | 100 | survived |+| traceway-android-disk | hot | 37095 | 338.281 | 87 | 316 | 100 | survived |+| traceway-android-disk | oom | 663 | 1813.470 | 823 | 191 | 100 | survived |+| traceway-android-mem | churn | 28238 | 7.657 | 289 | 693 | 99 | survived |+| traceway-android-mem | hot | 28387 | 6.030 | 337 | 689 | 100 | survived |+| traceway-android-mem | oom | 1924 | 829.739 | 3280 | 192 | 100 | survived |++Android is a different shape from JavaScript, because an R8 `mapping.txt` is small and cheap to compile, so churn never thrashes: every implementation holds its hot number under churn, including Honeycomb, whose JavaScript throughput collapsed under churn but here stays around 19-20k. What separates them is memory. Traceway disk mode runs about 37k stacks/s while holding 90 MB resident, against Honeycomb's 19-20k at 2.3 GB: nearly double the throughput on a twenty-fifth of the memory. Memory mode trades the other way, about 28k stacks/s at a 6ms p99 (no page-ins) for around 300 MB. Disk mode's ~338ms tail is the memory-map page-in on a cold `.tw`, and its throughput edge comes from retracing off the binary-searched flat artifact in place rather than a parsed map on the heap.++The `oom` row is an eviction soak: the cache is capped and every `mapping.txt` is padded to MB scale, so nothing stays warm. Everyone survives, but the trade inverts. Memory mode is fastest (1,924 stacks/s) because a miss just rebuilds in RAM, while disk mode pays a disk write-back and a fresh page-in on every miss (663 stacks/s) in exchange for holding RSS to 823 MB where Honeycomb needs 5.6 GB.++The throughline across all three languages: when the working set fits in RAM, memory mode owns the tail latency, and for the heavyweight DWARF formats the throughput too. When it doesn't, or you can't promise it always will, disk mode is the one that keeps running, holds memory flat, and warms instantly on restart; on a format as cheap to recompile as R8, it is even the faster of the two. Memory mode is the simpler default, disk mode the answer when RAM headroom, not latency, is the binding constraint.## Sizingdiff --git a/skills/traceway-setup/SKILL.md b/skills/traceway-setup/SKILL.mdindex b68854ca..bacfd1fc 100644--- a/skills/traceway-setup/SKILL.md+++ b/skills/traceway-setup/SKILL.md@@ -13,7 +13,7 @@ Connect an existing project to a Traceway instance so it reports endpoints, span|---|---|---|| **Instance URL** | `https://traceway.example.com` | The URL of the Traceway dashboard || **Project token** | `abc123...` | Traceway dashboard -> Connection page |-| **Upload token** (optional; frontend source maps, obfuscated Flutter symbols, and iOS dSYMs) | `def456...` | Traceway dashboard -> Connection page -> Source Maps / Symbol Upload |+| **Upload token** (optional; frontend source maps, obfuscated Flutter symbols, iOS dSYMs, and Android R8 mappings) | `def456...` | Traceway dashboard -> Connection page -> Source Maps / Symbol Upload |Instance URL and project token may be provided in the invocation (e.g. `/traceway-setup with token abc123 and url https://traceway.example.com`). If either is missing:@@ -249,7 +249,7 @@ For the per-framework init code (plain JS, React, Vue, Svelte/SvelteKit, jQuery)- **Flutter**: `flutter pub add traceway`, then `Traceway.run(connectionString: '<token>@https://<instance>/api/report', child: MyApp())`. Then check whether the release build is obfuscated (`--obfuscate --split-debug-info`): if it is, production crash stack traces arrive obfuscated and stay unreadable until the build's `.symbols` files are uploaded, so ask the user for the upload token (Step 0) and wire up the symbol upload. For options, platform permissions, the navigator observer, screen recording, privacy masking, the obfuscation check and symbol upload, and the Flutter web caveat, read `flutter.md` in this skill directory. Docs: https://docs.tracewayapp.com/client/flutter- **React Native**: `npm install @tracewayapp/react-native`, wrap the app in `TracewayProvider`. Docs: https://docs.tracewayapp.com/client/react-native-- **Android**: `implementation("com.tracewayapp:traceway:<version>")`, call `Traceway.init(...)` at startup. Docs: https://docs.tracewayapp.com/client/android+- **Android** (native Kotlin/Java): add `implementation("com.tracewayapp:traceway:1.0.1")` from Maven Central and call `Traceway.init(application = this, connectionString = "<token>@https://<instance>/api/report", options = TracewayOptions(version = "1.0.0"))` from `Application.onCreate()` (register the `Application` class and add the `INTERNET` permission in the manifest). It captures every uncaught Java/Kotlin exception on every thread plus manual `Traceway.captureException(...)`; errors and crashes only, no session replay. Release builds run R8, so production crashes arrive with renamed classes and rewritten line numbers and stay unreadable until the build's `mapping.txt` is uploaded: apply the `com.tracewayapp.symbols` Gradle plugin (`version "1.0.1"`, resolved from `mavenCentral()`), which injects `BuildConfig.TRACEWAY_PROGUARD_UUID` and uploads the mapping with the upload token (Step 0); pass that UUID into `TracewayOptions(proguardUuid = ...)` so each crash matches its mapping. For init code, options, the manifest, and the full Gradle plugin setup, read `android.md` in this skill directory. Docs: https://docs.tracewayapp.com/client/android- **iOS / Swift** (native SwiftUI or UIKit): add the Traceway iOS SDK via Swift Package Manager (`https://github.com/tracewayapp/traceway-ios.git`) and call `Traceway.start(connectionString: "<token>@https://<instance>/api/report", options: TracewayOptions(version: "1.0.0"))` as early as possible. It captures uncaught `NSException`s and fatal signals (hard crashes upload on the next launch) plus manual `Traceway.capture(...)`; it reports errors and crashes only (no session replay). Release crashes arrive as bare addresses until the build's dSYMs are uploaded, so set up dSYM upload with the upload token (Step 0). For init code, options, the debugger caveat, and dSYM upload, read `ios.md` in this skill directory. **If the app is NOT a Swift app** (Objective-C only, a cross-platform stack with no Traceway mobile SDK, or a team standardized on OpenTelemetry), there is no native SDK: use an OTel distribution like Honeycomb with its exporter pointed at `<instance>/api/otel` and a `Authorization: Bearer <project-token>` header, exactly like a backend (Step 2). The non-Swift path is also in `ios.md`.## Step 5: Deployment and Server Metricsdiff --git a/skills/traceway-setup/android.md b/skills/traceway-setup/android.mdnew file mode 100644index 00000000..92108b8f--- /dev/null+++ b/skills/traceway-setup/android.md@@ -0,0 +1,156 @@+# Android SDK Reference++Native Android apps (Kotlin or Java) use the Traceway Android SDK, `com.tracewayapp:traceway`, published on Maven Central. It reports **errors and crashes only**: there is no session or video replay (unlike Flutter). It speaks the same `/api/report` wire format as the iOS, Flutter, and JS SDKs, so the backend ingests it with no server changes.++For a cross-platform stack with no native code (React Native, or a team standardized on OpenTelemetry) use that platform's path instead; this file is for apps with a real Android (Kotlin/Java) module.++## Install++Add the dependency to the app module's `build.gradle.kts`:++```kotlin+dependencies {+ implementation("com.tracewayapp:traceway:1.0.1")+}+```++Maven Central is enabled by default in modern Android projects, so no extra `repositories { ... }` entry is needed. Minimum SDK is API 21.++## Initialize++Call `Traceway.init` from `Application.onCreate()`. This wraps the whole process, so every uncaught exception on every thread is captured automatically:++```kotlin+import android.app.Application+import com.tracewayapp.traceway.Traceway+import com.tracewayapp.traceway.TracewayOptions++class MyApp : Application() {+ override fun onCreate() {+ super.onCreate()+ Traceway.init(+ application = this,+ connectionString = "<project-token>@https://<instance>/api/report",+ options = TracewayOptions(version = "1.0.0"),+ )+ }+}+```++Register the `Application` class and add the `INTERNET` permission in `AndroidManifest.xml`, or reports cannot leave the device:++```xml+<manifest xmlns:android="http://schemas.android.com/apk/res/android">+ <uses-permission android:name="android.permission.INTERNET" />+ <application android:name=".MyApp" ...>+ ...+ </application>+</manifest>+```++Wire the token through a build setting or `BuildConfig` field, not a committed literal. The connection string format is `<project-token>@https://<instance>/api/report`, identical to the other mobile SDKs.++## Manual capture++```kotlin+try {+ riskyOperation()+} catch (e: Throwable) {+ Traceway.captureException(e)+}++Traceway.captureMessage("User completed onboarding")+Traceway.flush() // force-send pending events+```++## What gets captured automatically++After `init`, with no extra wiring:++- **Uncaught Java/Kotlin exceptions** on every thread, via `Thread.setDefaultUncaughtExceptionHandler`.+- **View click handler throws**, **background thread throws**, and **main `Handler.post` throws**.+- **Activity lifecycle transitions** recorded as navigation actions.++The last ~10 seconds of logs and actions ride along with each captured exception. `println` / `System.out` / `System.err` are mirrored automatically; `android.util.Log` lines are not, so install a Timber tree that calls `TracewayClient.instance?.recordLog(...)` if you need Logcat. Full option list (`sampleRate`, `debug`, channel toggles, on-disk persistence) is at https://docs.tracewayapp.com/client/android.++## Symbolication: upload R8 `mapping.txt` with the Gradle plugin++A release build with `minifyEnabled true` runs R8, which renames classes and methods and rewrites the line-number table, so production crash traces arrive obfuscated and stay unreadable until Traceway retraces them server-side against the build's `mapping.txt` (the Android equivalent of a JavaScript source map). Set this up whenever the app ships a minified release.++**Token.** Symbol uploads authenticate with the dedicated **upload token** (Connection page > Source Maps / Symbol Upload), NOT the project token from the connection string. Get it from Step 0; it is a CI secret, never committed. `readonly` members cannot generate one. Using the connection-string token here is rejected with a 401.++**Apply the plugin.** It is published to Maven Central, so add `mavenCentral()` to the `pluginManagement` repositories in `settings.gradle.kts`:++```kotlin+pluginManagement {+ repositories {+ gradlePluginPortal()+ mavenCentral() // resolves com.tracewayapp.symbols+ }+}+```++Then apply it to the app module and point it at the instance:++```kotlin+plugins {+ id("com.tracewayapp.symbols") version "1.0.1"+}++android {+ buildFeatures { buildConfig = true } // required for the injected UUID field+ buildTypes {+ release { isMinifyEnabled = true }+ }+}++traceway {+ uploadToken = "<upload-token>" // prefer a Gradle property / env var in CI+ url = "https://<instance>" // instance base URL+ autoUpload = false // true runs upload after assembleRelease+ // proguardUuid = "..." // optional: pin the build UUID yourself+}+```++**Wire the UUID into the SDK.** The plugin embeds a ProGuard UUID into `BuildConfig.TRACEWAY_PROGUARD_UUID` and names the uploaded mapping `<uuid>.txt`. The UUID is derived from the module path, variant, and app version (`versionName` + `versionCode`), so **bump the version each release** or a new upload overwrites the previous one (or set `proguardUuid` explicitly). Pass the injected value to the SDK so each reported crash carries the matching UUID:++```kotlin+Traceway.init(+ application = this,+ connectionString = "<project-token>@https://<instance>/api/report",+ options = TracewayOptions(+ version = "1.0.0",+ proguardUuid = BuildConfig.TRACEWAY_PROGUARD_UUID,+ ),+)+```++**Per release.** With `autoUpload = false` (the better fit for CI, so a release build never depends on backend availability) upload explicitly after the build:++```bash+./gradlew assembleRelease uploadReleaseTracewaySymbols+```++With `autoUpload = true` the upload runs automatically after `assembleRelease`. Keep the upload token in a secret and feed it through the environment or a Gradle property rather than the literal above:++```bash+TRACEWAY_UPLOAD_TOKEN=<upload-token> ./gradlew assembleRelease uploadReleaseTracewaySymbols+```++**Without the plugin.** The upload is a single multipart POST, so any pipeline can do it by hand: send the `mapping.txt` and its build UUID to `/api/symbols/upload`.++```bash+curl -fsS -H "Authorization: Bearer <upload-token>" \+ -F "files=@app/build/outputs/mapping/release/mapping.txt" \+ -F "proguard_uuid=<uuid>" \+ https://<instance>/api/symbols/upload+```++The `proguard_uuid` must match the value the SDK sends. Self-hosted instances must have blob storage (S3 or a persistent volume) configured, or uploaded mappings disappear when the container is recreated.++## Verify++1. Add a button that throws (`throw RuntimeException("Test error from Traceway")`), tap it, and confirm the error appears on the Issues page within a few seconds with its full stack trace.+2. For a minified release build: trigger a crash, then after `uploadReleaseTracewaySymbols` has run for that build, confirm the stack trace on Issues shows real class, method, and `file:line` rather than obfuscated `a.a.a(SourceFile)` frames.++For the symbolicator internals (how a trace is recognized, the retrace, and the `.tw` cache), see https://docs.tracewayapp.com/symbolicator/android.diff --git a/website/app/product/symbolication/page.tsx b/website/app/product/symbolication/page.tsxindex d851f5c8..da7a9703 100644--- a/website/app/product/symbolication/page.tsx+++ b/website/app/product/symbolication/page.tsx@@ -16,7 +16,7 @@ import { GITHUB_URL } from "@/lib/links";export const metadata: Metadata = {title: "Stack Trace Symbolication · Traceway",description:- "Open-source, OpenTelemetry-compatible symbolication for JavaScript source maps, Dart/Flutter obfuscation maps, and iOS/Swift dSYM debug symbols. Resolve minified production errors and stripped native crashes back to the original file, line, and function at ingest. Pure Go, built to be fast.",+ "Open-source, OpenTelemetry-compatible symbolication for JavaScript source maps, Dart/Flutter obfuscation maps, iOS/Swift dSYM debug symbols, and Android R8/ProGuard mapping files. Resolve minified production errors and stripped native crashes back to the original file, line, and function at ingest. Pure Go, built to be fast.",};const BUNDLERS = [@@ -38,7 +38,17 @@ const LANGUAGE_TILES = [h: 40,size: 80,z: 22,- pos: "left-[30%] top-1/2 -translate-x-1/2 -translate-y-1/2",+ pos: "left-[24%] top-1/2 -translate-x-1/2 -translate-y-1/2",+ engine: true,+ },+ {+ src: "/images/frameworks/android.png",+ alt: "Android",+ w: 45,+ h: 36,+ size: 80,+ z: 24,+ pos: "left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2",engine: true,},{@@ -48,7 +58,7 @@ const LANGUAGE_TILES = [h: 171,size: 104,z: 30,- pos: "left-[70%] top-1/2 -translate-x-1/2 -translate-y-1/2",+ pos: "left-[76%] top-1/2 -translate-x-1/2 -translate-y-1/2",engine: true,},{@@ -229,16 +239,17 @@ export default function SymbolicationPage() {className="mt-4 text-[22px] leading-tight text-pretty"style={{ color: "var(--fg-0)" }}>- JavaScript, Dart, Flutter, Swift, and more coming soon.+ JavaScript, Dart, Flutter, Swift, Android, and more coming soon.</h3><pclassName="mt-4 text-[15px] text-pretty"style={{ color: "var(--fg-2)" }}>One engine reads JavaScript source maps, Dart and Flutter- obfuscation maps, and iOS and Swift dSYM debug symbols through- the same compiled cache, plus every JS framework that ships- them, from React and Svelte to Next.js and Remix. Even on the+ obfuscation maps, iOS and Swift dSYM debug symbols, and Android+ R8 mapping files through the same compiled cache, plus every JS+ framework that ships them, from React and Svelte to Next.js and+ Remix. Even on thecheapest box we tested, a 2 vCPU Hetzner <code>ccx13</code>, it clears{" "}<strong style={{ color: "var(--fg-0)" }}>@@ -442,6 +453,10 @@ export default function SymbolicationPage() {q: "Does it symbolicate iOS and Swift crashes?",a: "Yes. Upload your build's .dSYM and the same engine resolves stripped Swift and Objective-C crash addresses back to file, line, and function, with inline frames expanded. dSYMs upload through the same per-project token and POST endpoint as your source maps, so a single Xcode build phase or a curl in CI keeps every release symbolicated.",},+ {+ q: "Does it symbolicate Android crashes?",+ a: "Yes. Release builds run R8, which renames classes and rewrites line numbers, so crashes arrive obfuscated. Upload the build's mapping.txt and the same engine retraces every frame back to the original class, method, file, and line, expanding the calls R8 inlined. The Gradle plugin injects a per-build UUID and uploads the mapping for you, through the same per-project token and POST endpoint as your source maps and dSYMs. On the OpenTelemetry path it reads the same app.debug.proguard_uuid attribute as Honeycomb, so a migrating app keeps its instrumentation.",+ },{q: "Are my source maps exposed publicly?",a: "No. Maps are uploaded to your Traceway instance's blob storage and used server-side only. They are never served to browsers, so you can keep .map files out of your deployed assets entirely.",diff --git a/website/public/images/frameworks/android.png b/website/public/images/frameworks/android.pngnew file mode 100644index 00000000..b5f0b5daBinary files /dev/null and b/website/public/images/frameworks/android.png differ