Hacktoberfest 2026: le issue che i maintainer hanno segnato per ottobre, aperte e adatte ai principianti. Sfoglia le issue Hacktoberfest

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

Aperta
  • Qualcosa non va?
#13,000 0 commenti 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

Nessuno ha ancora preso questa issue.

Valutazione

Difficoltà
5/5
Tempo stimato
Più di una settimana
Idoneità per principianti
35/100
Tipo di issue
Funzionalità
Chiarezza
Abbastanza chiara
Stato di attività
Attiva
Stack tecnologico
csharp
Ambito
devtools, observability-sre

Direzione di ricerca

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.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

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.

Lingua principale
C#
Stelle
2.1k
Fork
579
Merge medio
2g 3h
PR unite (30g)
216

Preparare l'ambiente

  • Nessun Dockerfile né file Docker Compose
  • Ha un modello di pull request
  • Nessuna guida per i contributori

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di dotnet/android

Tutte le issue di dotnet/android

Issue simili

Altre issue su C#

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.