Undersöka prestandaräknare (dotnet-räknare)

Den här artikeln gäller för version ✔️ dotnet-counters 3.0.47001 och senare versioner.

Räknare kan läsas från program som kör .NET 5 eller senare.

Installera

Det finns tre sätt att ladda ned och använda dotnet-counters:

• Enskottskörning (rekommenderas):

  Från och med .NET 10.0.100 kan du köra dotnet-counters utan permanent installation med hjälp av dnx:

  dnx dotnet-counters [options]
  

  Till exempel:

  dnx dotnet-counters monitor --process-id 1234
  

  Den här metoden laddar automatiskt ned och kör den senaste versionen utan att permanent ändra systemet.

• dotnet global tool:

  Om du vill installera den senaste versionen av dotnet-countersNuGet-paketet för frekvent användning använder du installationskommandot för dotnet-verktyget :

  dotnet tool install --global dotnet-counters
  

  Det här kommandot installerar en dotnet-counters binär fil till din .NET SDK Tools-sökväg, som du kan lägga till i din PATH för att enkelt anropa globalt installerade verktyg.

• Direkt nedladdning:

  Ladda ned det körbara verktyget som matchar din plattform:

  OS	Plattform
  Windows	x86 | x64 | Arm | Arm-x64
  Linux	x64 | Arm | Arm64 | musl-x64 | musl-Arm64

Sammanfattning

dotnet-counters [-h|--help] [--version] <command>

beskrivning

dotnet-counters är ett prestandaövervakningsverktyg för ad hoc-hälsoövervakning och prestandaundersökning på första nivån. Den kan observera prestandaräknarens värden som publiceras via API:et EventCounter eller API:et Meter . Du kan till exempel snabbt övervaka saker som cpu-användning eller antalet undantag som genereras i .NET Core-programmet för att se om det finns något misstänkt innan du går in på allvarligare prestandaundersökningar med hjälp av PerfView eller dotnet-trace.

Alternativ

• --version

  Visar versionen av dotnet-counters verktyget.

• -h|--help

  Visar kommandoradshjälp.

Kommandon

dotnet-counters samlar in

Samla regelbundet in valda räknarvärden och exportera dem till ett angivet filformat för efterbearbetning.

Sammanfattning

dotnet-counters collect [-h|--help] [-p|--process-id] [-n|--name] [--diagnostic-port] [--refresh-interval] [--counters <COUNTERS>] [--format] [-o|--output] [-- <command>]

Alternativ

• -p|--process-id <PID>

  ID:t för den process som du vill samla in motdata från.

  Kommentar

  I Linux och macOS kräver det här alternativet målprogrammet och dotnet-counters att samma TMPDIR miljövariabel delas. Annars överskrider kommandot tidsgränsen.

• -n|--name <name>

  Namnet på den process som räknardata ska samlas in från.

  Kommentar

  I Linux och macOS kräver det här alternativet målprogrammet och dotnet-counters att samma TMPDIR miljövariabel delas. Annars överskrider kommandot tidsgränsen.

• --diagnostic-port <port-address[,(listen|connect)]>

  Anger den diagnostikport som används för att kommunicera med processen som ska övervakas. dotnet-counters och .NET-körningen i målprocessen måste komma överens om portadressen, där den ena lyssnar och den andra ansluter. dotnet-counters fastställer automatiskt rätt port vid anslutning med hjälp av --process-id alternativen eller --name eller när du startar en process med hjälp av -- <command> alternativet . Det är vanligtvis bara nödvändigt att uttryckligen ange porten när du väntar på en process som startar i framtiden eller kommunicerar med en process som körs i en container som inte ingår i det aktuella processnamnområdet.

  Skiljer port-address sig åt beroende på operativsystem:

  • Linux och macOS – en sökväg till en Unix-domänsocket, till exempel /foo/tool1.socket.
  • Windows – en sökväg till ett namngivet rör, till exempel \\.\pipe\my_diag_port1.
  • Android, iOS och tvOS – en IP:port som 127.0.0.1:9000.

  Som standard dotnet-counters lyssnar på den angivna adressen. Du kan begära dotnet-counters att ansluta i stället genom att lägga till ,connect efter adressen. Anslut till exempel --diagnostic-port /foo/tool1.socket,connect till en .NET-körningsprocess som lyssnar på /foo/tool1.socket Unix-domänsocketen.

  Information om hur du använder det här alternativet för att starta övervakningsräknare från appstart finns i använda diagnostikport.

• --refresh-interval <SECONDS>

  Antalet sekunder som ska fördröjas mellan uppdatering av de visade räknarna

• --counters <COUNTERS>

  En kommaavgränsad lista över räknare. Räknare kan anges provider_name[:counter_name]. provider_name Om används utan en kvalificerande lista över räknare visas alla räknare från providern. Information om provider- och räknarnamn finns i inbyggda mått. För EventCountersprovider_name är namnet på EventSource och för Meter, provider_name namnet på mätaren.

• --format <csv|json>

  Det format som ska exporteras. För närvarande tillgänglig: csv, json.

• -o|--output <output>

  Namnet på utdatafilen.

• -- <command>

  Efter insamlingskonfigurationsparametrarna kan användaren lägga till -- följt av ett kommando för att starta ett .NET-program. dotnet-counters startar en process med det angivna kommandot och samlar in de begärda måtten. Detta är ofta användbart för att samla in mått för programmets startsökväg och kan användas för att diagnostisera eller övervaka problem som inträffar tidigt före eller strax efter huvudstartpunkten.

  Kommentar

  Med det här alternativet övervakas den första .NET-processen som kommunicerar tillbaka till verktyget, vilket innebär att om kommandot startar flera .NET-program samlar det bara in den första appen. Därför rekommenderar vi att du använder det här alternativet i fristående program eller använder alternativet dotnet exec <app.dll> .

  Kommentar

  Om du startar en körbar .NET-fil via dotnet-countersomdirigeras dess indata/utdata och du kommer inte att kunna interagera med dess stdin/stdout. Du kan avsluta verktyget via Ctrl+C eller SIGTERM för att på ett säkert sätt avsluta både verktyget och den underordnade processen. Om den underordnade processen avslutas innan verktyget avslutas även verktyget. Om du behöver använda stdin/stdout kan du använda alternativet --diagnostic-port . Mer information finns i Använda diagnostikport.

Exempel

• Samla in alla räknare med ett uppdateringsintervall på 3 sekunder och generera en csv som utdata:

  > dotnet-counters collect --process-id 1902 --refresh-interval 3 --format csv
  
  --counters is unspecified. Monitoring System.Runtime counters by default.
  Starting a counter session. Press Q to quit.
  

• Starta dotnet mvc.dll som en underordnad process och börja samla in runtime-räknare och ASP.NET Core Hosting-räknare från start och spara dem som JSON-utdata:

  > dotnet-counters collect --format json --counters System.Runtime,Microsoft.AspNetCore.Hosting -- dotnet mvc.dll
  Starting a counter session. Press Q to quit.
  File saved to counter.json
  

dotnet-counters monitor

Visar regelbundet uppdateringsvärden för valda räknare.

Sammanfattning

dotnet-counters monitor [-h|--help] [-p|--process-id] [-n|--name] [--diagnostic-port] [--refresh-interval] [--counters] [-- <command>]

Alternativ

• -p|--process-id <PID>

  ID för den process som ska övervakas.

• -n|--name <name>

  Namnet på den process som ska övervakas.

• --diagnostic-port

  Namnet på diagnostikporten som ska skapas. Mer information om hur du använder det här alternativet för att starta övervakningsräknare från appstart finns i Använda diagnostikport .

• --refresh-interval <SECONDS>

  Antalet sekunder som ska fördröjas mellan uppdatering av de visade räknarna

• --counters <COUNTERS>

  En kommaavgränsad lista över räknare. Räknare kan anges provider_name[:counter_name]. provider_name Om används utan en kvalificerande lista över räknare visas alla räknare från providern. Information om provider- och räknarnamn finns i inbyggda mått. För EventCountersprovider_name är namnet på EventSource och för Meter, provider_name namnet på mätaren.

• -- <command>

  Efter insamlingskonfigurationsparametrarna kan du lägga till -- följt av ett kommando för att starta ett .NET-program. dotnet-counters startar en process med det angivna kommandot och övervakar de begärda måtten. Detta är ofta användbart för att samla in mått för programmets startsökväg och kan användas för att diagnostisera eller övervaka problem som inträffar tidigt före eller strax efter huvudstartpunkten.

  Kommentar

  Med det här alternativet övervakas den första .NET-processen som kommunicerar tillbaka till verktyget, vilket innebär att om kommandot startar flera .NET-program samlar det bara in den första appen. Därför rekommenderar vi att du använder det här alternativet i fristående program eller använder alternativet dotnet exec <app.dll> .

  Kommentar

  Om du startar en körbar .NET-fil via dotnet-counters omdirigeras indata/utdata och du kan inte interagera med dess stdin/stdout. Du kan avsluta verktyget via Ctrl+C eller SIGTERM för att på ett säkert sätt avsluta både verktyget och den underordnade processen. Om den underordnade processen avslutas innan verktyget avslutas även verktyget. Om du behöver använda stdin/stdout kan du använda alternativet --diagnostic-port . Mer information finns i Använda diagnostikport.

Exempel

• Övervaka alla räknare från System.Runtime med ett uppdateringsintervall på 3 sekunder:

  > dotnet-counters monitor --process-id 1902  --refresh-interval 3 --counters System.Runtime
  Press p to pause, r to resume, q to quit.
      Status: Running
  Name                                              Current Value
  [System.Runtime]
      dotnet.assembly.count ({assembly})                               115
      dotnet.gc.collections ({collection})
          gc.heap.generation
          ------------------
          gen0                                                           5
          gen1                                                           1
          gen2                                                           1
      dotnet.gc.heap.total_allocated (By)                       1.6947e+08
      dotnet.gc.last_collection.heap.fragmentation.size (By)
          gc.heap.generation
          ------------------
          gen0                                                           0
          gen1                                                     348,248
          gen2                                                           0
          loh                                                           32
          poh                                                            0
      dotnet.gc.last_collection.heap.size (By)
          gc.heap.generation
          ------------------
          gen0                                                           0
          gen1                                                  18,010,920
          gen2                                                   5,065,600
          loh                                                       98,384
          poh                                                    3,407,048
      dotnet.gc.last_collection.memory.committed_size (By)      66,842,624
      dotnet.gc.pause.time (s)                                           0.05
      dotnet.jit.compilation.time (s)                                    1.317
      dotnet.jit.compiled_il.size (By)                             574,886
      dotnet.jit.compiled_methods ({method})                         6,008
      dotnet.monitor.lock_contentions ({contention})                   194
      dotnet.process.cpu.count ({cpu})                                  16
      dotnet.process.cpu.time (s)
          cpu.mode
          --------
          system                                                         4.953
          user                                                           6.266
      dotnet.process.memory.working_set (By)                             1.3217e+08
      dotnet.thread_pool.queue.length ({work_item})                      0
      dotnet.thread_pool.thread.count ({thread})                       133
      dotnet.thread_pool.work_item.count ({work_item})              71,188
      dotnet.timer.count ({timer})                                     124
  

  Kommentar

  Om appen använder .NET version 8 eller lägre finns inte System.Runtime Meter i dessa versioner och dotnet-counters återgår till att visa de äldre System.Runtime EventCounters i stället. Användargränssnittet ser lite annorlunda ut, vilket visas här.

  [System.Runtime]
        % Time in GC since last GC (%)                                 0
        Allocation Rate (B / 1 sec)                                5,376
        CPU Usage (%)                                                  0
        Exception Count (Count / 1 sec)                                0
        GC Fragmentation (%)                                          48.467
        GC Heap Size (MB)                                              0
        Gen 0 GC Count (Count / 1 sec)                                 1
        Gen 0 Size (B)                                                24
        Gen 1 GC Count (Count / 1 sec)                                 1
        Gen 1 Size (B)                                                24
        Gen 2 GC Count (Count / 1 sec)                                 1
        Gen 2 Size (B)                                           272,000
        IL Bytes Jitted (B)                                       19,449
        LOH Size (B)                                              19,640
        Monitor Lock Contention Count (Count / 1 sec)                  0
        Number of Active Timers                                        0
        Number of Assemblies Loaded                                    7
        Number of Methods Jitted                                     166
        POH (Pinned Object Heap) Size (B)                             24
        ThreadPool Completed Work Item Count (Count / 1 sec)           0
        ThreadPool Queue Length                                        0
        ThreadPool Thread Count                                        2
        Working Set (MB)                                              19
  

• Övervaka bara skräpsamlingar och skräpinsamlings-heapallokering från System.Runtime:

  > dotnet-counters monitor --process-id 1902 --counters System.Runtime[dotnet.gc.collections,dotnet.gc.heap.total_allocated]
  
  Press p to pause, r to resume, q to quit.
  Status: Running
  
  Name                                  Current Value
  [System.Runtime]
      dotnet.gc.collections ({collection})
          gc.heap.generation
          ------------------
          gen0                                0
          gen1                                0
          gen2                                0
      dotnet.gc.heap.total_allocated (By)     9,943,384
  
  

• Övervaka EventCounter värden från användardefinierade EventSource. Mer information finns i Självstudie: Mäta prestanda med EventCounters i .NET Core.

  > dotnet-counters monitor --process-id 1902 --counters Samples-EventCounterDemos-Minimal
  
  Press p to pause, r to resume, q to quit.
      request                                      100
  

• Starta my-aspnet-server.exe och övervaka antalet sammansättningar som lästs in från starten:

  > dotnet-counters monitor --counters System.Runtime[dotnet.assembly.count] -- my-aspnet-server.exe
  Press p to pause, r to resume, q to quit.
  Status: Running
  
  Name                               Current Value
  [System.Runtime]
  dotnet.assembly.count ({assembly})      11
  

• Starta my-aspnet-server.exe med arg1 och arg2 som kommandoradsargument och övervaka dess arbetsuppsättning och GC-heapstorlek från starten:

  > dotnet-counters monitor --counters System.Runtime[dotnet.process.memory.working_set,dotnet.gc.last_collection.heap.size] -- my-aspnet-server.exe arg1 arg2
  

  Name                                             Current Value
  [System.Runtime]
      dotnet.gc.last_collection.heap.size (By)
          gc.heap.generation
          ------------------
          gen0                                          560
          gen1                                      462,720
          gen2                                            0
          loh                                             0
          poh                                         8,184
      dotnet.process.memory.working_set (By)     48,431,104
  
  

dotnet-counters ps

Visar en lista över de dotnet-processer som kan övervakas av dotnet-counters. dotnet-counters version 6.0.320703 och senare visar även de kommandoradsargument som varje process startades med, om den är tillgänglig.

Sammanfattning

dotnet-counters ps [-h|--help]

Exempel

Anta att du startar en tidskrävande app med kommandot dotnet run --configuration Release. I ett annat fönster kör dotnet-counters ps du kommandot . De utdata du ser är följande. Eventuella kommandoradsargument visas i dotnet-counters version 6.0.320703 och senare.

> dotnet-counters ps

  21932 dotnet     C:\Program Files\dotnet\dotnet.exe   run --configuration Release
  36656 dotnet     C:\Program Files\dotnet\dotnet.exe

Använda diagnostikport

Diagnostikport är en körningsfunktion som gör att du kan börja övervaka eller samla in räknare från appstart. Om du vill göra detta med kan dotnet-countersdu antingen använda dotnet-counters <collect|monitor> -- <command> enligt beskrivningen i föregående exempel eller använda alternativet --diagnostic-port .

Att använda dotnet-counters <collect|monitor> -- <command> för att starta programmet som en underordnad process är det enklaste sättet att snabbt övervaka det från starten.

Men när du vill få en finare kontroll över appens livslängd som övervakas (till exempel övervaka appen under de första 10 minuterna och fortsätta köra) eller om du behöver interagera med appen med hjälp av CLI kan du med hjälp av --diagnostic-port alternativet styra både målappen som övervakas och dotnet-counters.

1. Följande kommando skapar dotnet-counters en diagnostiksocket med namnet myport.sock och väntar på en anslutning.

   dotnet-counters collect --diagnostic-port myport.sock
   

   Utdata:

   Waiting for connection on myport.sock
   Start an application with the following environment variable: DOTNET_DiagnosticPorts=/home/user/myport.sock
   

2. Starta målprogrammet i en separat konsol med miljövariabeln DOTNET_DiagnosticPorts inställd på värdet i dotnet-counters utdata.

   export DOTNET_DiagnosticPorts=/home/user/myport.sock
   ./my-dotnet-app arg1 arg2
   

   På så sätt kan dotnet-counters du börja samla in räknare på my-dotnet-app:

   Waiting for connection on myport.sock
   Start an application with the following environment variable: DOTNET_DiagnosticPorts=myport.sock
   Starting a counter session. Press Q to quit.
   

   Viktigt!

   Det kan vara problematiskt att starta din app med dotnet run eftersom dotnet CLI kan skapa många underordnade processer som inte är din app och de kan ansluta till dotnet-counters innan din app, vilket gör att appen kan pausas vid körning. Vi rekommenderar att du direkt använder en fristående version av appen eller använder dotnet exec för att starta programmet.