Métricas de tempo de execução do .NET
Este artigo descreve as métricas internas para bibliotecas de tempo de execução do .NET que são produzidas usando a System.Diagnostics.Metrics API. Para obter uma lista de métricas com base na API EventCounters mais antiga, consulte Contadores disponíveis.
Gorjeta
Para obter mais informações sobre como coletar e relatar essas métricas, consulte Coletando métricas.
System.Runtime
O System.Runtime
medidor relata medições do GC, JIT, AssemblyLoader, Threadpool e partes de tratamento de exceções do tempo de execução do .NET, bem como algumas métricas de CPU e memória do sistema operacional. Essas métricas estão disponíveis automaticamente para todos os aplicativos .NET.
Métrica: dotnet.process.cpu.time
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.process.cpu.time |
Contador | s |
Tempo de CPU utilizado pelo processo. |
Atributo | Tipo | Description | Exemplos | Presença |
---|---|---|---|---|
cpu.mode |
string | O modo da CPU. | user ; system |
Sempre |
Essa métrica relata os mesmos valores que acessar as propriedades de tempo do processador para System.Diagnostics.Process o processo atual. O system
modo corresponde a e user
o PrivilegedProcessorTime modo corresponde aUserProcessorTime
Disponível a partir de: .NET 9.0.
Métrica: dotnet.process.memory.working_set
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.process.memory.working_set |
UpDownCounter | By |
O número de bytes de memória física mapeados para o contexto do processo. |
Essa métrica relata os mesmos valores da propriedade de chamada Environment.WorkingSet .
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.collections
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.collections |
Contador | {collection} |
O número de coletas de lixo que ocorreram desde o início do processo. |
Atributo | Tipo | Description | Exemplos | Presença |
---|---|---|---|---|
dotnet.gc.heap.generation |
string | Nome da geração máxima de heap gerenciado que está sendo coletada. | gen0 ; gen1 ; gen2 |
Sempre |
O .NET GC é um coletor de lixo geracional. Cada vez que o coletor de lixo é executado, ele usa heurística para selecionar uma geração máxima e, em seguida, coleta objetos em todas as gerações até o máximo selecionado. Por exemplo, uma gen1
coleção reúne todos os objetos das gerações 0 e 1. Uma gen2
coleção reúne todos os objetos das gerações 0, 1 e 2. Para obter mais informações sobre o .NET GC e a coleta de lixo geracional, consulte o guia de coleta de lixo do .NET.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.heap.total_allocated
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.heap.total_allocated |
Contador | By |
O número aproximado de bytes alocados no heap GC gerenciado desde o início do processo. O valor retornado não inclui nenhuma alocação nativa. |
Essa métrica relata os mesmos valores que chamar GC.GetTotalAllocatedBytes. Para obter mais informações sobre o .NET GC, consulte o guia de coleta de lixo do .NET.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.last_collection.memory.committed_size
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.last_collection.memory.committed_size |
UpDownCounter | By |
A quantidade de memória virtual confirmada em uso pelo .NET GC, conforme observado durante a coleta de lixo mais recente. |
Essa métrica relata os mesmos valores que chamar GCMemoryInfo.TotalCommittedBytes. A memória virtual confirmada pode ser maior do que o tamanho da pilha porque inclui memória para armazenar objetos existentes (o tamanho da pilha) e alguma memória extra pronta para lidar com objetos recém-alocados no futuro. Para obter mais informações sobre o .NET GC, consulte o guia de coleta de lixo do .NET.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.last_collection.heap.size
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.last_collection.heap.size |
UpDownCounter | By |
O tamanho da pilha GC gerenciada (incluindo fragmentação), conforme observado durante a coleta de lixo mais recente. |
Atributo | Tipo | Description | Exemplos | Presença |
---|---|---|---|---|
dotnet.gc.heap.generation |
string | Nome do coletor de lixo gerenciado geração de heap. | gen0 ; gen1 loh ;; gen2 poh |
Sempre |
O .NET GC divide a pilha em gerações. Além das gerações numeradas padrão, o GC também coloca alguns objetos em duas gerações especiais:
- Large object heap (LOH) armazena objetos .NET que são muito grandes em comparação com objetos típicos.
- O heap de objeto fixo (POH) armazena objetos alocados usando a GC.AllocateArray API quando o
pinned
parâmetro é true.
Ambas as gerações especiais são coletadas durante gen2
as coletas de GC. Para obter mais informações sobre o .NET GC, consulte o guia de coleta de lixo do .NET.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.last_collection.heap.fragmentation.size
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.last_collection.heap.fragmentation.size |
UpDownCounter | By |
A fragmentação da pilha, como observado durante a última coleta de lixo. |
Essa métrica relata os mesmos valores que chamar GCGenerationInfo.FragmentationAfterBytes.
Quando os objetos .NET são alocados, inicialmente eles tendem a ser dispostos de forma contígua na memória. No entanto, se alguns desses objetos forem coletados posteriormente pelo GC, isso criará lacunas de memória não utilizadas entre os objetos vivos que permanecem. Essas lacunas representam a parte da pilha GC que não está sendo usada atualmente para armazenar objetos, muitas vezes chamada de "fragmentação". O GC pode reutilizar os bytes de fragmentação no futuro para novas alocações de objetos se o tamanho do objeto for pequeno o suficiente para caber em uma das lacunas. O GC também pode executar uma coleta de lixo de compactação especial que move os objetos vivos restantes próximos uns dos outros, desde que os objetos não tenham sido fixados no lugar.
Para obter mais informações sobre como o GC do .NET funciona, analisando o desempenho do GC e qual a fragmentação de função desempenhada, consulte Análise de desempenho de memória do .NET.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.gc.pause.time
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.gc.pause.time |
Contador | s |
A quantidade total de tempo pausado no GC desde o início do processo. |
Essa métrica relata os mesmos valores que chamar GC.GetTotalPauseDuration().
Cada vez que o .NET GC faz uma coleção, ele precisa pausar brevemente todos os threads que executam código gerenciado para determinar quais objetos ainda são referenciados. Essa métrica relata a soma de todos esses tempos de pausa desde o início do processo. Você pode usar essa métrica para determinar qual fração de tempo os threads gastam pausados para GC versus o tempo que eles são capazes de executar código gerenciado.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.jit.compiled_il.size
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.jit.compiled_il.size |
Contador | By |
Contagem de bytes de linguagem intermediária que foram compilados desde o início do processo. |
Essa métrica relata os mesmos valores que chamar JitInfo.GetCompiledILBytes.
Quando você cria um aplicativo .NET, o código gerenciado é inicialmente compilado de uma linguagem de alto nível como C#, VB ou F# em linguagem intermediária (IL). Em seguida, quando o programa é executado, o compilador .NET just-in-time (JIT) converte o IL em código de máquina.
Como a compilação JIT ocorre na primeira vez que um método é executado, a maior parte da compilação JIT tende a ocorrer durante a inicialização do aplicativo. Reduzir a quantidade de IL compilada pelo JIT pode melhorar o tempo de inicialização do aplicativo.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.jit.compiled_methods
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.jit.compiled_methods |
Contador | {method} |
O número de vezes que o compilador JIT (re)compilou métodos desde o início do processo. |
Essa métrica relata os mesmos valores que chamar JitInfo.GetCompiledMethodCount.
Quando você cria um aplicativo .NET, o código gerenciado é inicialmente compilado de uma linguagem de alto nível como C#, VB ou F# em linguagem intermediária (IL). Em seguida, quando o programa é executado, o compilador .NET just-in-time (JIT) converte o IL em código de máquina.
Como a compilação JIT ocorre na primeira vez que um método é executado, a maior parte da compilação JIT tende a ocorrer durante a inicialização do aplicativo. Reduzir o número de métodos que precisam ser compilados JIT pode melhorar o tempo de inicialização do aplicativo.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.jit.compilation.time
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.jit.compilation.time |
Contador | s |
A quantidade de tempo que o compilador JIT gastou compilando métodos desde o início do processo. |
Essa métrica relata os mesmos valores que chamar JitInfo.GetCompilationTime.
Quando você cria um aplicativo .NET, o código gerenciado é inicialmente compilado de uma linguagem de alto nível como C#, VB ou F# em linguagem intermediária (IL). Em seguida, quando o programa é executado, o compilador .NET just-in-time (JIT) converte o IL em código de máquina.
Como a compilação JIT ocorre na primeira vez que um método é executado, a maior parte da compilação JIT tende a ocorrer durante a inicialização do aplicativo. Reduzir o tempo gasto na compilação JIT pode melhorar o tempo de inicialização do aplicativo.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.thread_pool.thread.count
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.thread_pool.thread.count |
UpDownCounter | {thread} |
O número de threads de pool de threads que existem atualmente. |
Essa métrica relata os mesmos valores que chamar ThreadPool.ThreadCount.
O .NET usa um pool de threads para agendar itens de trabalho em outros threads. Essa métrica fornece o número de threads de trabalho atualmente gerenciados por esse pool de threads.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.thread_pool.work_item.count
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.thread_pool.work_item.count |
Contador | {work_item} |
O número de itens de trabalho que o pool de threads concluiu desde o início do processo. |
Essa métrica relata os mesmos valores que chamar ThreadPool.CompletedWorkItemCount.
O .NET usa um pool de threads para agendar itens de trabalho em outros threads. Essa métrica fornece o número de itens de trabalho que foram executados pelos threads do pool de threads.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.thread_pool.queue.length
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.thread_pool.queue.length |
UpDownCounter | {work_item} |
O número de itens de trabalho que estão atualmente na fila para serem processados pelo pool de threads. |
Essa métrica relata os mesmos valores que chamar ThreadPool.PendingWorkItemCount.
O .NET usa um pool de threads para agendar itens de trabalho em outros threads. Essa métrica fornece o número de itens de trabalho que estão atualmente na fila para serem executados por um dos threads do pool de threads.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.monitor.lock_contentions
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.monitor.lock_contentions |
Contador | {contention} |
O número de vezes que houve contenção ao tentar adquirir um bloqueio de monitor desde o início do processo. |
Essa métrica relata os mesmos valores que chamar Monitor.LockContentionCount.
O .NET oferece suporte ao uso de qualquer objeto gerenciado como um bloqueio, seja com APIs como Monitor.Enter ou com a instrução lock. Se um thread já mantém um bloqueio enquanto um segundo thread tenta adquiri-lo, isso é chamado de contenção de bloqueio.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.timer.count
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.timer.count |
UpDownCounter | {timer} |
O número de instâncias de timer que estão ativas no momento. |
Essa métrica relata os mesmos valores que chamar Timer.ActiveCount.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.assembly.count
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.assembly.count |
UpDownCounter | {assembly} |
O número de assemblies .NET que estão carregados no momento. |
Essa métrica relata os mesmos valores que chamar AppDomain.GetAssemblies() e, em seguida, verificar o comprimento da matriz retornada.
Disponível a partir de: .NET 9.0.
Métrica: dotnet.exceptions
Nome | Tipo de Instrumento | Unidade (UCUM) | Description |
---|---|---|---|
dotnet.exceptions |
Contador | {exception} |
O número de exceções que foram lançadas no código gerenciado. |
Atributo | Tipo | Description | Exemplos | Presença |
---|---|---|---|---|
error.type |
string | O tipo de exceção que foi lançado. | System.OperationCanceledException ; Contoso.MyException |
Required |
Essa métrica relata os mesmos valores que a contagem de chamadas para o AppDomain.FirstChanceException evento.
Disponível a partir de: .NET 9.0.