Hacktoberfest 2026: the issues maintainers tagged for October, open and beginner-friendly. Browse Hacktoberfest issues

Add a skill to interpret Android runtime events in .nettrace files

Open
  • Is something wrong?
#13,000 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
5/5
Estimated time
Over a week
Newbie friendliness
35/100
Issue type
Feature
Clarity
Mostly clear
Activity status
Active
Tech stack
csharp
Domain
devtools, observability-sre

Research direction

Start by locating the repository’s skill conventions and reading the runtime’s documented event schema; use the issue’s session-local TraceEvent decoder example and original .nettrace files as investigation references. Done means a repository skill can answer focused lifetime and GC-bridge queries while explaining event loss, missing data, and uncertainty, without adding a permanent trace-reader project or product dependency.

Written by the indexing model from the issue text.

Description

enhancement needs-triage
Android framework version

net11.0-android (Preview)

Affected platform version

.NET 11 Android runtime diagnostics, covering CoreCLR and NativeAOT.

Description

Add a repository skill that accepts a local .nettrace file and interprets our custom Microsoft.Android.Runtime events. This is a follow-up to #6822 and the local experiment moving JNI global/local/weak-global reference diagnostics to EventSource.

The skill should provide cross-platform investigation on Windows, macOS, and Linux without adding a permanent trace-reader project or dependency to the Android solution/product. A small session-local decoder using Microsoft.Diagnostics.Tracing.TraceEvent is one possible implementation detail.

Suggested coverage:

  • Decode event names, IDs, timestamps, keywords, levels, and typed payloads; correlate GC bridge/type-map timing with reference operations.
  • Track creation, deletion, ownership release, and Java GC collection of global/local/weak-global references. Distinguish local-reference ownership release from actual JNI deletion.
  • Correlate numeric handles with Java identity hashes, managed peer/type diagnostics, managed thread IDs, and bridge-operation context. Account for handle reuse and concurrent counter snapshots rather than treating the trace as one atomic history.
  • Display CoreCLR EventPipe call stacks and interpret the opt-in NativeAOT ReferenceStackTrace payloads, correlated by reference event ID, handle, and managed thread ID.
  • Report event loss, late attachment, abrupt-crash truncation, missing events/stacks, and uncertainty explicitly. Absence of an event is not proof an operation did not happen.
  • Allow focused queries such as “what happened to handle 0x75?”, “where was this peer disposed?”, and “what happened during this GC bridge round?”.

dotnet-trace report and its Speedscope/Chromium conversions do not expose the custom event payloads needed for these investigations. Preserve and interpret the original .nettrace file.

Steps to Reproduce
  1. Build an Android application with EnableDiagnostics=true and EventSourceSupport=true; use startup suspension when a complete initial reference history is needed.
  2. Collect global/weak-global events using dotnet-trace collect --dsrouter android-emu --providers Microsoft.Android.Runtime:0x10:5 -o references.nettrace, or use 0x30 to include local references.
  3. For NativeAOT managed stack payloads, additionally enable keyword 0x40 (0x50 for globals/weak-globals plus stacks; 0x70 to include locals).
  4. Ask the proposed skill to analyze the original trace, identify relevant lifetimes, and explain the evidence and collection limitations.

The new reference event IDs/keywords above describe the current local experiment, not a shipped contract. The skill should follow the runtime's documented event schema as it evolves.

Did you find any workaround?

A small prototype reader was validated against real CoreCLR and NativeAOT Android emulator traces. It is being removed from the repository/solution; the following example preserves the useful decoding approach for future skill development.

Example: session-local TraceEvent decoder

Use a console project referencing Microsoft.Diagnostics.Tracing.TraceEvent (the experiment used version 3.1.21). This is an example, not a request to add a permanent tool project.

using System;
using System.Globalization;
using System.IO;
using Microsoft.Diagnostics.Tracing.Etlx;

if (args.Length != 1) {
    Console.Error.WriteLine("Usage: decoder TRACE.nettrace");
    return 2;
}

string convertedPath = Path.Combine (
    Path.GetTempPath (), $"android-trace-{Guid.NewGuid ():N}.etlx");
try {
    TraceLog.CreateFromEventPipeDataFile (args [0], convertedPath);
    using var trace = new TraceLog (convertedPath);
    if (trace.EventsLost != 0) {
        Console.Error.WriteLine (
            $"WARNING: {trace.EventsLost} events were lost; histories are incomplete.");
    }
    Console.Error.WriteLine (
        "Operations before collection and final events at abrupt exit may be missing.");

    int eventCount = 0;
    foreach (var entry in trace.Events) {
        if (entry.ProviderName != "Microsoft.Android.Runtime") {
            continue;
        }
        eventCount++;
        Console.Write (string.Create (CultureInfo.InvariantCulture,
            $"{entry.TimeStampRelativeMSec:F3}ms thread={entry.ThreadID} {entry.EventName}"));
        for (int i = 0; i < entry.PayloadNames.Length; i++) {
            string name = entry.PayloadNames [i];
            object value = entry.PayloadValue (i);
            Console.Write ($" {name}=");
            if (value is ulong handle &&
                (name == "handle" || name == "sourceHandle")) {
                Console.Write (string.Create (
                    CultureInfo.InvariantCulture, $"0x{handle:x}"));
            } else {
                Console.Write (Convert.ToString (value, CultureInfo.InvariantCulture));
            }
        }
        Console.WriteLine ();
        for (var stack = entry.CallStack (); stack != null; stack = stack.Caller) {
            Console.WriteLine ($"   at {stack.CodeAddress.FullMethodName}");
        }
    }
    if (eventCount == 0) {
        Console.Error.WriteLine ("No Microsoft.Android.Runtime events found.");
        return 1;
    }
    return trace.EventsLost == 0 ? 0 : 1;
} finally {
    if (File.Exists (convertedPath)) {
        File.Delete (convertedPath);
    }
}

This prints raw evidence. The skill still needs schema-aware interpretation and correlation, especially when traces are partial. NativeAOT stack strings are event payloads, not CallStack() entries.

Relevant log output

The local experiment decoded ordinary JNI reference events, peer diagnostics, local-reference releases, and Java GC collection on both runtimes. CoreCLR provided application call stacks through EventPipe. NativeAOT provided no EventPipe call stacks; the opt-in fallback produced 148 correlated managed stack events containing application frames. Ordinary NativeAOT collection with keyword mask 0x30 emitted no stack-string events.

By opening the issue you agree to follow this project's Code of Conduct.

Dominant language
C#
Stars
2.1k
Forks
581
Avg merge
2d 33m
Merged PRs (30d)
204

Getting set up

  • No Dockerfile or Docker Compose file
  • Has a pull request template
  • No contributing guide

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from dotnet/android

All issues in dotnet/android

Similar issues

More C# issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.