explaingit

ismkdc/dottop

18C#Audience · ops devopsComplexity · 2/5Setup · easy

TLDR

Live terminal dashboard for .NET web apps showing CPU, memory, request rates, error counts, and latency, no code changes needed, just point it at your running process.

Mindmap

mindmap
  root((dottop))
    Metrics
      CPU and memory
      Garbage collection
      Thread pool state
      Allocation rate
    Web Stats
      Requests per second
      Error rates
      Latency percentiles
      Top endpoints table
    Attach Methods
      Interactive process list
      Process ID or name
      Probe script mode
    Platforms
      Linux x86 and ARM
      Alpine musl
      Windows
    Containers
      Docker support
      Kubernetes pods
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Monitor a live .NET web app's CPU, memory, and request throughput in real time without restarting or modifying the app.

USE CASE 2

Spot slow or error-prone API endpoints by checking the ranked endpoint table during a performance issue.

USE CASE 3

Run a quick health probe over SSH or in a CI script to capture a snapshot of app metrics.

USE CASE 4

Diagnose .NET apps running inside Docker or Kubernetes by copying the binary into the container and attaching directly.

Tech stack

C#.NET.NET Diagnostics APITerminal UI

Getting it running

Difficulty · easy Time to first run · 5min

Single self-contained binary (~15 MB). Run it on the same machine as your .NET process, no app changes or SDK setup needed. For containers, copy the binary in first.

License not mentioned in the explanation.

In plain English

dottop is a terminal dashboard that shows live health metrics for .NET web applications while they are running, without requiring any changes to the application itself. You run it on the same machine as the .NET process, point it at the process by name or ID, and it immediately starts displaying CPU usage, memory, request throughput, error rates, and latency numbers in an htop-style screen. The tool connects through a built-in .NET diagnostics channel that .NET itself already exposes. This is the same channel used by official Microsoft tools, so no special SDK setup or application restart is needed. It collects runtime counters covering garbage collection behavior, thread pool state, memory allocation rate, and exception frequency, alongside web-specific numbers such as active requests, requests per second, failed requests, and latency percentiles at the 50th, 95th, and 99th percentile. It also builds a table of the hottest endpoints ranked by traffic, showing average and maximum response times along with error counts per route. Attaching works a few different ways. Running dottop with no arguments shows a list of all running .NET processes and lets you pick one. You can also attach directly by passing a process ID or a partial process name. A non-interactive probe mode runs for a fixed number of seconds and prints a summary, which is useful in scripts or over SSH. For applications running inside Docker containers or Kubernetes pods, the README describes how to copy the binary into the container and run it from there, since the diagnostics socket lives inside the container's filesystem. The binary is self-contained and around 15 MB. It runs on Linux (x86-64 and ARM64), Alpine Linux with the musl variant, and Windows. The author notes this was built quickly with AI assistance and has been tested against real applications but may have rough edges in less common scenarios.

Copy-paste prompts

Prompt 1
I'm using dottop to monitor my .NET API. The p95 latency is spiking but error rate looks normal. What are the most likely causes and how do I dig deeper?
Prompt 2
My .NET app's memory keeps climbing according to dottop's allocation rate counter. Walk me through how to interpret garbage collection metrics to find the leak.
Prompt 3
How do I run dottop in probe mode inside a Kubernetes pod so I can capture a 30-second metrics snapshot and pipe it to a log file?
Prompt 4
dottop shows my thread pool is exhausted during peak traffic. What does that mean for my .NET web app and what should I change in my code?
Prompt 5
Walk me through attaching dottop to a .NET process running inside a Docker container step by step.
Open on GitHub → Explain another repo

← ismkdc on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.