Cheap Windows Hosting Review

Stopwatch for.NET Core Application Performance Monitoring

Posted on by Pablo Francesco

Requests frequently move synchronously or asynchronously across several services in a distributed architecture. Finding performance bottlenecks, particularly when implementing new changes, is made easier by monitoring the processing times of each component and the entire sequence. The effectiveness, overhead, and recommended practices for high-throughput systems of the Stopwatch class in.NET Core are examined in this article along with how to utilize it for performance monitoring.

Why Use a Stopwatch for performance monitoring?

The Stopwatch class is specifically designed for high-precision and efficient elapsed time measurement, making it an ideal choice for profiling and performance monitoring in .NET Core applications. Compared to alternatives such as DateTime.UtcNow or DateTime.Now, Stopwatch Offers:

  • Higher Precision: Uses high-resolution timers.
  • Better Performance: Avoids the overhead of system calls required for retrieving the current time.

Benchmarking Stopwatch Overhead

The performance impact of Stopwatch is minimal, as shown in this simple benchmark:

Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 1000000; i++)
{
    sw.Stop();
    sw.Restart();
}
sw.Stop();
Console.WriteLine($"Elapsed Time for 1M operations: {sw.ElapsedMilliseconds} ms");

Result: On a local machine, this benchmark takes around 10ms to execute, demonstrating the negligible overhead of Stopwatch.

When to Avoid Stopwatch

Although Stopwatch is efficient, there are scenarios where its overhead might be undesirable:

  1. Extremely High-Throughput Applications: For applications processing millions of messages per second, even nanosecond-level overhead can accumulate.
  2. Redundant Timing Logic: Measuring every step in complex workflows might lead to excessive and unnecessary timing logic.

Alternatives for High-Throughput Scenarios

  • Batch-Level Measurements: Measure processing times at a batch level instead of per message.
  • Application Profiling Tools: Use tools like Visual Studio Diagnostics, PerfView, or Application Insights for profiling.

Using Stopwatch in Concurrent Scenarios

Stopwatch is not thread-safe by design but works well when instantiated independently per task or thread. Here’s how to use it effectively in concurrent message processing:

Example. RabbitMQ Consumer with Stopwatch

using System;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;

public class RabbitMqHostedService
{
    private readonly IConnection _connection;
    private readonly IModel _channel;

    public RabbitMqHostedService()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();

        _channel.QueueDeclare(queue: "sourceQueue", durable: true, exclusive: false, autoDelete: false, arguments: null);
        _channel.QueueDeclare(queue: "destinationQueue", durable: true, exclusive: false, autoDelete: false, arguments: null);
    }

    public void StartProcessing()
    {
        var consumer = new EventingBasicConsumer(_channel);
        consumer.Received += async (model, ea) =>
        {
            await Task.Run(() =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);

                var stopwatch = Stopwatch.StartNew();

                try
                {
                    ProcessMessage(message);
                    var processedMessage = Encoding.UTF8.GetBytes(message);

                    _channel.BasicPublish(exchange: "", routingKey: "destinationQueue", basicProperties: null, body: processedMessage);
                }
                finally
                {
                    stopwatch.Stop();
                    Console.WriteLine($"Message processed in {stopwatch.ElapsedMilliseconds} ms");
                }

                _channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
            });
        };

        _channel.BasicConsume(queue: "sourceQueue", autoAck: false, consumer: consumer);
    }

    private void ProcessMessage(string message)
    {
        Task.Delay(50).Wait(); // Simulate processing time
    }
}

Example with Middleware

You can also use Stopwatch in middleware to measure the time taken to process HTTP requests. Here’s an example:

public class MessageTimingMiddleware
{
    private readonly RequestDelegate _next;

    public MessageTimingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        await _next(context);
        stopwatch.Stop();

        // Log or send timing information to a monitoring system
        Console.WriteLine($"Message processed in {stopwatch.ElapsedMilliseconds} ms");
    }
}

This approach is particularly useful for monitoring and profiling APIs or services in a web application.

Key Points in the Code

  1. Independent Stopwatch Instances: Each message creates its own Stopwatch instance, avoiding concurrency issues.
  2. Asynchronous Processing: Task.Run ensures concurrent message processing without blocking the main thread.

Performance Validation

To assess the impact of adding Stopwatch, simulate high-throughput scenarios, and measure system performance:

Test Setup

  • Pod Size: 200MB memory, 30mCPU
  • Throughput: 40 requests/second (baseline)
  • After Stopwatch: 38 requests/second (5% reduction)

Optimization Strategies

  1. Batch Processing: Fetch and process messages in batches (e.g., 10-50 messages at a time).
  2. Prefetch Count: Configure RabbitMQ consumer prefetch count to balance the load.
  3. Aggregate Metrics: Log average processing times at periodic intervals instead of per message.

Advanced Monitoring Tools

For high-throughput systems, consider using specialized tools for distributed tracing and metrics aggregation:

1. Application Performance Monitoring (APM) Tools

Azure Application Insights: Track request durations, dependencies, and custom metrics.

var telemetry = new TelemetryClient();
var startTime = DateTime.UtcNow;
var stopwatch = Stopwatch.StartNew();

// Message processing logic
ProcessMessage(message);

stopwatch.Stop();
telemetry.TrackDependency("RabbitMQ", "MessageProcessing", startTime, stopwatch.Elapsed, true);

2. Distributed Tracing with OpenTelemetry

  • Instrument RabbitMQ consumers and producers for end-to-end tracing.
  • Visualize traces in tools like Jaeger, Prometheus, or Grafana. 
    using OpenTelemetry;
using OpenTelemetry.Trace;

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("RabbitMQ.Processing")
    .AddConsoleExporter()
    .Build();

var activitySource = new ActivitySource("RabbitMQ.Processing");
using (var activity = activitySource.StartActivity("ProcessMessage"))
{
    ProcessMessage(message);
    activity?.SetTag("message.id", messageId);
    activity?.SetTag("processing.duration", stopwatch.ElapsedMilliseconds);
}

3. Log-Based Timing Analysis

Use tools like Elastic Stack (ELK) to analyze logs for processing times:

Log Format:

{
  "messageId": "12345",
  "timestamp": "2025-01-24T10:30:00.000Z",
  "event": "MessageReceived"
}

Visualization: Use Kibana to calculate and visualize timing differences.

Conclusion

Stopwatch is a powerful and efficient tool for measuring processing times in distributed systems. While it introduces minimal overhead, high-throughput scenarios might benefit from alternative approaches like batch processing, aggregated metrics, or APM tools. By combining Stopwatch with advanced monitoring solutions, you can gain valuable insights into system performance and optimize workflows effectively.

Best ASP.NET 8.0.11 Core Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFEASP.NET, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.

hostforlifebanner