Continous Profiling in .NET

Summary

Continuous Profiling is a practice that is gaining more and more space in software development and observability routines, providing valuable insights into the behavior of applications in production. In this context, Pyroscope appears as a robust and versatile tool, which can bring considerable benefits to .NET projects, improving efficiency, reliability and, consequently, the quality of the software produced.

Continous Profiling - How to use Pyroscope in .NET

Technology has helped companies take the next step towards innovation and digital transformation. In this sense, the implementation of Continuous Profiling with Pyroscope in .NET can contribute to guarantee the reliability of the product, allowing this important evolution.

In the previous article, we discussed the concept of Continuous Profiling and how it can identify problems in production and reduce MTTR . Now, let's dig deeper and explore the practical implementation of Continuous Profiling using Pyroscope in .NET applications, a powerful feature that can bring observability to a new level in our software projects.

What is Pyroscope?

Pyroscope is an open source performance analysis platform. Its main function is to help developers better understand the performance of their applications, identifying bottlenecks and improving the overall efficiency of the code.

With the primary goal of guiding the identification and resolution of performance issues, Pyroscope offers continuous visibility, detailed analysis and support for multiple programming languages.

Continuous visibility

Unlike most traditional performance analysis tools, which provide a point-in-time or periodic view of application performance, providing continuous visibility. This makes it possible to observe how your application's performance changes over time.

Detailed analysis

Pyroscope allows developers to examine resource usage in a very detailed way. It is possible to explore even individual functions within the code, enabling an in-depth analysis of where resources are being used and where possible bottlenecks may be arising.

Support for multiple programming languages

Pyroscope is a flexible tool for software development teams as it supports a variety of programming languages. So far, it has native support for Go, Python, Ruby, and .NET, with plans to expand support to other languages in the future.

Implementing Pyroscope in .NET

Before starting the implementation, the complete project is on my Github . The first step in integrating Pyroscope into your .NET project is to add the Pyroscope package reference. We are using version 0.8.4 in this example.

1
dotnet add package Pyroscope

After running this command, the .NET CLI will add the following line to your .csproj file:

1
2
3
<ItemGroup>
    <PackageReference Include="Pyroscope" Version="0.8.4" />
</ItemGroup>

The next step in configuring Pyroscope is to enable specific tracking functionality. Pyroscope provides a number of settings that allow you to track different aspects of your application's performance.

1
Pyroscope.Profiler.Instance.SetAllocationTrackingEnabled(true);

This line enables tracking of memory allocations. This will help you better understand how your application is using memory and can help identify memory leaks or inefficient memory usage.

1
Pyroscope.Profiler.Instance.SetExceptionTrackingEnabled(true);

This line enables exception tracing. This will allow you to see which parts of your code are throwing exceptions and can help identify problem areas in your code.

1
Pyroscope.Profiler.Instance.SetContentionTrackingEnabled(true);

This line enables contention tracing. This can help identify places in your code where multiple threads are competing for the same resources, which can lead to degraded performance.

1
Pyroscope.Profiler.Instance.SetCPUTrackingEnabled(true);

This line enables CPU usage tracking. This can help identify areas of your code that are using a disproportionate amount of CPU resources.

Adding labels to categorize and filter profiling data

In Pyroscope , labels are an efficient way to categorize and filter your profiling data . They provide an additional way to segment your metrics for more granular analysis. In the context of .NET, you can add labels anywhere in your code where you want deeper insights .

1
2
3
4
5
6
var labels = Pyroscope.LabelSet.Empty.BuildUpon().Add("WeatherForecast", "Get").Build();
 
Pyroscope.LabelsWrapper.Do(labels, () => 
{
 // Your code
});

Next, we define the Dockerfile, and finally, docker-compose.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
FROM --platform=linux/amd64 mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
 
RUN apt-get update && apt-get -y install wget
RUN wget -qO- https://github.com/grafana/pyroscope-dotnet/releases/download/v0.8.4-pyroscope/pyroscope.glibc.tar.gz  \
     | tar xvz
 
EXPOSE 80
 
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["Demo.Profiling.csproj", "."]
RUN dotnet restore "./Demo.Profiling.csproj"
 
COPY . .
WORKDIR "/src/."
RUN dotnet build "Demo.Profiling.csproj" -c Release -o /app/build
 
FROM build AS publish
RUN dotnet publish "Demo.Profiling.csproj" -c Release -o /app/publish -r $(dotnet --info | grep RID | cut -b 6- | tr -d ' ')
 
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
 
ENV CORECLR_ENABLE_PROFILING=1
ENV CORECLR_PROFILER={BD1A650D-AC5D-4896-B64F-D6FA25D6B26A}
ENV CORECLR_PROFILER_PATH=/app/Pyroscope.Profiler.Native.so
ENV LD_PRELOAD=/app/Pyroscope.Linux.ApiWrapper.x64.so
 
ENV PYROSCOPE_LOG_LEVEL=info
ENV PYROSCOPE_PROFILING_ENABLED=1
ENV PYROSCOPE_PROFILING_ALLOCATION_ENABLED=true
ENV PYROSCOPE_PROFILING_CONTENTION_ENABLED=true
ENV PYROSCOPE_PROFILING_EXCEPTION_ENABLED=true
 
ENTRYPOINT ["dotnet", "/app/Demo.Profiling.dll"]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
version: "3.9"
 
services:
 
  demo:
    build: 
      context: ./src
    container_name: demo
    ports:
      - 7000:80
    environment:
      - PYROSCOPE_APPLICATION_NAME=demo.profiling
      - PYROSCOPE_SERVER_ADDRESS=http://pyroscope:4040
    networks:
      - demo
 
  pyroscope:
    container_name: pyroscope
    image: pyroscope/pyroscope:latest
    command:
      - server
    ports:
      - 4040:4040
    deploy:
      resources:
        limits:
          memory: 300M
    restart: always
    networks:
      - demo      
 
networks:
  demo:
    driver: bridge    

Conclusion

We discussed the importance of Continuous Profiling for companies' innovation and digital transformation. We delved into the practical implementation in .NET using Pyroscope – an open performance analysis platform. We looked at Pyroscope's key features, including continuous visibility, detailed analysis, and support for multiple programming languages. Finally, we present a step-by-step guide to implementing Pyroscope in a .NET project, from adding the package to the application to defining the Dockerfile and docker-compose.

>> EVOLUIR É MELHOR QUE REVOLUCIONAR <<

https://tiagotartari.net/continuous-profiling-como-implementar-o-pyroscope-no-net.html

agni-tech

Search This Blog

Cloud Product Mapping