Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

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

Abierto
  • ¿Algo no está bien?
#13,000 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 1 día

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
5/5
Tiempo estimado
Más de una semana
Aptitud para principiantes
35/100
Tipo de issue
Nueva funcionalidad
Claridad
Bastante claro
Estado de actividad
Activo
Stack tecnológico
csharp
Área
devtools, observability-sre

Línea de trabajo

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.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

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.

Lenguaje dominante
C#
Estrellas
2.1k
Forks
581
Merge medio
1 d 17 h
PR fusionados (30 d)
249

Preparar el entorno

  • Sin Dockerfile ni archivo de Docker Compose
  • Tiene una plantilla de pull request
  • Sin guía de contribución

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de dotnet/android

Todos los issues de dotnet/android

Issues similares

Más issues de C#

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.