Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

profiling

/profiling

Diagnozuje aplikacje .NET darmowymi oficjalnymi narzędziami: wysokie zużycie CPU, presję GC, wzrost alokacji i lawiny wyjątków.

Repozytorium
dotnet-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
5
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Diagnozuje aplikacje .NET darmowymi oficjalnymi narzędziami: wysokie zużycie CPU, presję GC, wzrost alokacji i lawiny wyjątków.

Oryginalny opis (EN)

Use the free official .NET diagnostics CLI tools for profiling and runtime investigation in .NET repositories. USE FOR: the repo needs performance or runtime profiling for a .NET application; the user asks about slow code, high CPU, GC pressure, allocation growth, exception storms, lock. DO NOT USE FOR: replacing realistic performance tests or load tests with ad-hoc tracing alone; production heap collection when the pause risk has not been. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.

Jak działa

  1. Trigger On
  2. Value
  3. Do Not Use For
  4. Inputs
  5. Quick Start
  6. Workflow
  7. Bootstrap When Missing
  8. Deliver
  9. Validate
  10. Ralph Loop
Sekcje z nagłówków SKILL.md, w oryginale · 130 linii, 789 słów
Podgląd SKILL.md
---
name: profiling
description: "Use the free official .NET diagnostics CLI tools for profiling and runtime investigation in .NET repositories. USE FOR: the repo needs performance or runtime profiling for a .NET application; the user asks about slow code, high CPU, GC pressure, allocation growth, exception storms, lock. DO NOT USE FOR: replacing realistic performance tests or load tests with ad-hoc tracing alone; production heap collection when the pause risk has not been. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made."
compatibility: "Requires a .NET app or process to inspect; respects the repo's `AGENTS.md` commands first."
---

# .NET Profiling

## Trigger On

- the repo needs performance or runtime profiling for a .NET application
- the user asks about slow code, high CPU, GC pressure, allocation growth, exception storms, lock contention, or startup diagnostics
- the team wants official CLI-based diagnostics without depending on `dnx`

## Value

- produce a concrete project delta: code, docs, config, tests, CI, or review artifact
- reduce ambiguity through explicit planning, verification, and final validation skills
- leave reusable project context so future tasks are faster and safer

## Do Not Use For

- replacing realistic performance tests or load tests with ad-hoc tracing alone
- production heap collection when the pause risk has not been accepted
- GUI-only workflows that the repo cannot automate or document

## Inputs

- the nearest `AGENTS.md`
- target application, process, or startup path
- the symptom being investigated: CPU, memory, GC, contention, exceptions, or startup

## Quick Start

1. Read the nearest `AGENTS.md` and confirm scope and constraints.
2. Run this skill's `Workflow` through the `Ralph Loop` until outcomes are acceptable.
3. Return the `Required Result Format` with concrete artifacts and verification evidence.

## Workflow

1. Build and run a realistic target first:
   - prefer `Release`
   - prefer realistic config, inputs, and data volume
2. Start with the lightest useful tool:
   - `dotnet-counters` for live health signals
   - `dotnet-trace` for CPU, exception, contention, GC, and startup traces
   - `dotnet-gcdump` for managed heap inspection when memory shape matters
3. Prefer installed CLI tools over `dnx` one-shot execution so the repo commands stay stable and reproducible.
4. Capture one focused profile at a time instead of mixing every signal into one run.
5. For CPU and general runtime hotspots, start with `dotnet-trace collect`.
6. For live triage, start with `dotnet-counters monitor` on `System.Runtime`.
7. For heap analysis, use `dotnet-gcdump` carefully and document the pause risk.
8. After each change, rerun the same measurement path and compare before versus after.

## Bootstrap When Missing

If official .NET profiling tools are not available yet:

1. Detect current state:
   - `dotnet --info`
   - `dotnet tool list --global`
   - `command -v dotnet-counters`
   - `command -v dotnet-trace`
   - `command -v dotnet-gcdump`
2. Choose the install path deliberately:
   - preferred machine-level install:
     - `dotnet tool install --global dotnet-counters`
     - `dotnet tool install --global dotnet-trace`
     - `dotnet tool install --global dotnet-gcdump`
   - direct-download fallback when global tools are not suitable:
     - use the official Microsoft Learn download links for `dotnet-counters`, `dotnet-trace`, and `dotnet-gcdump`
3. Verify the installed tools resolve correctly:
   - `dotnet-counters --version`
   - `dotnet-trace --version`
   - `dotnet-gcdump --version`
4. Record exact profiling commands in `AGENTS.md`, for example:
   - `dotnet-counters monitor --process-id PID --counters System.Runtime`
   - `dotnet-trace collect --process-id PID --profile dotnet-common,dotnet-sampled-thread-time -o trace.nettrace`
   - `dotnet-gcdump collect --process-id PID --output heap.gcdump`
5. Run one bounded command and return `status: configured` or `status: improved`.
6. If the repo intentionally standardizes on another profiling stack and does not want these tools, return `status: not_applicable`.

## Deliver

- explicit official .NET profiling commands
- a clear profiling path for CPU, counters, and heap inspection
- reproducible diagnostics commands that humans and agents can rerun

## Validate

- the chosen tool matches the actual symptom
- commands target a realistic process and configuration
- before/after comparisons use the same scenario
- heap collection warnings are explicit when `dotnet-gcdump` is used

## Ralph Loop

Use the Ralph Loop for every task, including docs, architecture, testing, and tooling work.

1. Plan first (mandatory):
   - analyze current state
   - define target outcome, constraints, and risks
   - write a detailed execution plan
   - list final validation skills to run at the end, with order and reason
2. Execute one planned step and produce a concrete delta.
3. Review the result and capture findings with actionable next fixes.
4. Apply fixes in small batches and rerun the relevant checks or review steps.
5. Update the plan after each iteration.
6. Repeat until outcomes are acceptable or only explicit exceptions remain.
7. If a dependency is missing, bootstrap it or return `status: not_applicable` with explicit reason and fallback path.

### Required Result Format

- `status`: `complete` | `clean` | `improved` | `configured` | `not_applicable` | `blocked`
- `plan`: concise plan and current iteration step
- `actions_taken`: concrete changes made
- `validation_skills`: final skills run, or skipped with reasons
- `verification`: commands, checks, or review evidence summary
- `remaining`: top unresolved items or `none`

For setup-only requests with no execution, return `status: configured` and exact next commands.

## Load References

- [references/commands.md](references/commands.md)
- [references/patterns.md](references/patterns.md)
- [references/profiling.md](references/profiling.md)

## Example Requests

- "Profile this .NET app for CPU hotspots."
- "Investigate GC pressure in this service."
- "Capture counters and a trace from startup."
- "Set up official .NET profiling tools for local investigations."
Pliki w paczce (5)
  • SKILL.md 6 KB
  • manifest.json 1 KB
  • references/commands.md 9 KB
  • references/patterns.md 14 KB
  • references/profiling.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · managedcode/dotnet-skills100MIT
kevinpbuckley/vibeue100MIT
KittenML/inferencekit100Apache-2.0
nvidia/omniperf100Apache-2.0
arjunprabhulal/devops-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki d3f20bfdce06 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100asynkron-profiler
    Profiluje z poziomu CLI polecenia .NET lub istniejące pliki śladów narzędziem Asynkron.Profiler: CPU, alokacje, wyjątki, contention i sterta, z wyjściem przyjaznym dla automatyzacji.
  • 100stryker
    Sprawdza, czy testy .NET wychwytują błędy, przez mutacje w Stryker.NET, zwłaszcza w krytycznych bibliotekach i domenach.
  • 100go-pprof-profiling
    Diagnozuje wysokie użycie CPU, rosnącą pamięć, wycieki goroutines i konflikty mutexów w Go przy użyciu pprof, flamegraphów, profili heap, runtime/trace i zrzutów goroutines.
  • 100performance-profiling
    Znajduje i naprawia problemy wydajności backendu: mierzy p95 i p99, profiluje CPU, pamięć, I/O i blokady, a po poprawce dodaje test regresji.
  • 90gc-pressure-auditor
    Diagnozuje presję GC w usłudze .NET: Large Object Heap, Gen2, tempo alokacji i konfigurację, a potem proponuje poprawki.
  • 100profiling-application-performance
    Profiluje wydajność aplikacji: zużycie CPU i pamięci oraz czas wykonania, wskazując wąskie gardła i rekomendacje optymalizacji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.