DOCSEARCHbyAlgolia
Submit Docs

Measure Documentation

repository·main·Indexed 23 days ago

https://github.com/measure-sh/measure

An open-source mobile observability platform and alternative to Firebase Crashlytics for monitoring crashes, ANRs, and performance bottlenecks. The project includes the measure.sh SDK, an Android Gradle Plugin for instrumentation, and a backend architecture featuring a Golang API server, an Ingest Worker Service supporting Google Cloud Pub/Sub and Apache Iggy, an alerts service, and a cleanup service.

Tokens
110.1K
Snippets
266
Records
622
Agent score
79%

What's inside Measure

  1. Overview of Measure features

    main

    Measure is a mobile observability platform designed to help teams monitor and fix crashes, ANRs, bugs, and performance issues. Key features include:

    • Session Timelines: Automatic tracking of clicks, navigations, and HTTP calls to provide full context for debugging.
    • App Health: Monitoring of important metrics and deltas to track app stability.
    • Crashes and ANRs: Automatic tracking of crashes and Application Not Responding (ANR) events with stacktraces and screenshots.
    • Performance Traces: Analysis of app performance using traces and spans to identify bottlenecks.
    • Bug Reports: Capture bug reports via device shake or SDK calls, including the history of user actions leading to the bug.
    • User Journeys: Visualization of how users move through screens to identify areas most affected by issues.
    • Network Performance: Monitoring of endpoints to identify slow or error-prone network calls.
    • Adaptive Capture: Dynamic adjustment of data collection parameters without requiring app updates.
    • Measure Agent: Natural language debugging via Slack or coding agents using MCP, providing context on crashes, errors, sessions, and traces.

  2. Overview of Measure REST APIs

    main

    Measure provides two distinct sets of REST APIs designed around standard REST principles. Both sets accept and return JSON and utilize standard HTTP response codes.

    1. SDK endpoints: These are used by Measure SDKs to ingest events, spans, and build artifacts from applications. Developers should only interact with these endpoints directly when building a custom integration.
    2. Dashboard API: This is used by the Measure dashboard to fetch data (sessions, crashes, ANRs, performance data, etc.) and to manage resources like apps, teams, and alerts.

  3. Overview of Network Monitoring in Measure

    main

    Measure captures mobile app network requests, responses, and failures. For every request, it records the URL, HTTP method, status code, latency, and failure reason. To prevent data overload, URLs are automatically grouped into endpoint patterns.

    Privacy & Data Collection: By default, request and response headers and bodies are not collected. To capture sensitive data, you must explicitly opt-in via the HTTP events settings in the dashboard. Measure also records connectivity changes to help distinguish between API failures and network availability issues.

  5. Overview of Measure: Open Source Mobile App Monitoring

    main

    Measure is an open-source mobile app monitoring and crash reporting platform designed as an alternative to Firebase Crashlytics. It provides mobile teams with a centralized dashboard to monitor and resolve crashes, ANRs (App Not Responding), bugs, and performance issues across various platforms including Android, iOS, and Flutter (with React Native support coming soon).

    Key capabilities include:

    • Crash & ANR Reporting: Monitor app stability and failures.
    • Performance Traces: Analyze app performance and startup times.
    • Session Timelines: View complete context for user sessions.
    • Network Performance: Monitor network-related telemetry.
    • Adaptive Capture: Dynamically control data collection without requiring app updates to manage costs and data volume.
    • Intelligent Debugging: Integrate with Slack via Measure Agent or use the MCP Server to connect with coding agents for direct querying of errors, traces, and timelines.

  6. Overview of the Ingest Worker Service

    main

    The Ingest Worker Service is responsible for receiving IngestBatch messages from a message bus and executing the full event processing pipeline. It is designed to scale independently from the ingest service based on the message backlog.

    Supported backends include:

    • Google Cloud Pub/Sub (cloud): Supports both pull-based consumption and HTTP push endpoints.
    • Apache Iggy (self-hosted): Uses a pull-based consumer group with manual offset commits.

  8. Overview of available macro-benchmarks

    main

    The benchmark suite consists of several specialized tests to measure the impact of the Measure SDK:

    • Startup Benchmark: Measures cold startup of the :baseline-target app over 35 iterations. It tracks timeToInitialDisplayMs and a TraceSectionMetric for msr-init (the synchronous time spent inside Measure.init).
    • View Click Benchmark: Measures the synchronous cost of gesture tracking on a standard XML View hierarchy by tapping a Button three times per iteration over 35 warm-start iterations.
    • Compose Click Benchmark: Similar to the View benchmark, but targets a material3.Button in a Compose hierarchy to exercise LayoutInspector's Compose semantics traversal.
    • Baseline Profile Generator: Runs the BaselineProfileRule to capture code paths exercised during cold start (including Measure.init). This profile is used by the :measure library.

  11. Understand Measure's monitoring capabilities

    main

    Measure is designed for mobile engineering teams and goes beyond basic error tracking. Key capabilities include:

    • Session Timelines: Provides full context of errors and performance issues as they occur in production.
    • Beyond Crashes: Focuses on the full picture of app health, not just error reporting.
    • Flexible Data Ingestion: You can send any combination of errors, metrics, and spans without being restricted by artificial bundles or tiers.

  12. Monitor Android app performance and health

    main

    Measure provides several monitoring capabilities for Android apps:

    Performance Traces

    Instrument critical operations like API fetches, database calls, and screen rendering. These are visualized using waterfall charts to identify bottlenecks and are linked to full session timelines.

    App Health

    Track key metrics across releases:

    • App adoption
    • Crash-free and ANR-free session rates
    • Error rates
    • App size
    • Launch times (Cold, Warm, and Hot starts)

    Network Monitoring

    Track HTTP request performance, including:

    • HTTP status code distributions
    • Endpoint latency
    • Error rates per endpoint
    • Request frequency