Moonglade

Modern Markdown blogging with AI-powered localization and search.

Tag: performance

Recent Featured
14
MAR

Why Is My API Slow as a Snail? Series Table of Contents and Guide ★

This series of articles aims to address the challenges of slow API response times and difficult fault debugging in production environments, systematically introducing methods for analyzing and handling online issues. The first part focuses on how to use Serilog to configure comprehensive structured logging, capturing critical timing and diagnostic information, and leveraging Seq for centralized log management, thereby helping developers easily analyze logs and quickly pinpoint performance bottlenecks. The second part delves into the application of OpenTelemetry, demonstrating how to achieve correlated analysis of distributed tracing, metrics, and logs through a unified framework, thereby enhancing the reliability and operational efficiency of software systems. This series is suitable for developers and operations personnel who wish to optimize system performance, monitor runtime status, and rapidly identify root causes. All articles are simultaneously published on WeChat Official Accounts and both domestic and international blog platforms, facilitating multi-platform reading and learning for readers.

Views 98
.NET OpenTelemetry Performance Serilog performance analysis structured logging
13
MAR

Why is my API as slow as a snail? - 3. Seq Centralized Structured Logging Service

This article is the third in the "Why Is My API as Slow as a Snail?" series, focusing on how to use Seq for centralized collection and analysis of logs from multiple instances. The article first compares Seq with ELK, noting that Seq is more lightweight and easier to deploy, making it suitable for quickly setting up a logging center. It then provides a detailed demonstration of how to quickly deploy the Seq service using Docker and explains the meaning of key configuration parameters. Next, the author shows how to integrate `Serilog.Sinks.Seq`, requiring only a few lines of code in the configuration file to push application logs to Seq in real time. Finally, using Seq's Web interface and a SQL-like query syntax, it is easy to filter out request logs with a duration exceeding 1000ms, thereby precisely locating the code causing performance bottlenecks. This solution addresses the challenge of cross-instance analysis associated with traditional local logs, providing a data-driven basis for performance optimization rather than relying on guesswork, and laying the foundation for subsequent in-depth Tracing analysis.

Views 95
.NET Logging Performance Seq Web API performance analysis
12
MAR

Why Is My API Slow as a Snail? - 2. Serilog Timing and Diagnostic Logging

This article introduces how to leverage Serilog in ASP.NET Core to achieve efficient performance measurement and diagnostics. First, by integrating the SerilogTimings package, you can use the Operation.Time context manager to easily record the execution time of code snippets, transforming vague performance guesses into precise structured data, which helps quickly pinpoint performance bottlenecks in database queries or I/O tasks. Second, by enabling the UseSerilogRequestLogging middleware, the system can automatically log each HTTP request's method, path, status code, and total duration, and generate a unique RequestId, facilitating the correlation and analysis of a single request's complete lifecycle in the logs. Additionally, the article demonstrates how to customize the message template for request logs, as well as how to inject IDiagnosticContext to append business metadata such as UserId and Username to the logs, thereby enabling precise tracking of specific user behavior trajectories. These practices greatly simplify the process of troubleshooting production issues, allowing teams to shift from passive guessing to data-driven precise optimization, significantly enhancing the quality of software services and operational efficiency.

Views 78
.NET Diagnostic Information HTTP Request Logging Performance Serilog Timing Metrics
12
MAR

Why is my API slow as a snail? - 1. Using Serilog Structured Logging

This article introduces the complete process of integrating Serilog into ASP.NET Core 7 to implement structured logging. First, install the Serilog.AspNetCore package and utilize its built-in Console, Debug, and File Sinks; for monolithic applications, configuring file logging alone is sufficient to meet the requirements. Second, modify the configuration file to define log levels, output destinations, and formatters. Use a compact JSON format for logging and enable contextual information such as machine name and thread ID. Next, take over the default logging system in Program.cs by using Host.UseSerilog, and output logs in the controller for verification. For exceptions during the application startup phase, configure a Bootstrap Logger using Serilog's global static Log class, combined with a Try-Catch-Finally structure to ensure that startup errors are fully recorded. Finally, the article demonstrates that the generated structured logs contain key tracking data such as ActionId and RequestId, and recommends choosing to store logs in a database or using tools like Seq for centralized analysis and management based on team needs.

Views 84
.NET ASP.NET Core C# Performance Serilog Web API
12
MAR

.NET Performance Tips: Why You Should Avoid Using Finalizers?

This article provides an in-depth exploration of why developers should avoid using finalizers in .NET and their performance impact. It points out that finalizers cause objects to be promoted to a higher generation, preventing them from being quickly reclaimed in Generation 0, and requiring them to wait for a dedicated finalizer thread to execute. This significantly increases memory usage and garbage collection cycles, leading to uncontrollable performance overhead. Benchmark test data shows that when creating and releasing the same number of objects, classes with finalizers take approximately 18 times longer, or even more, than regular classes, with the specific gap depending on the environment. The article advises developers to avoid using finalizers and instead adopt the standard pattern of implementing the `IDisposable` interface in conjunction with the `GC.SuppressFinalize` method to release resources. This approach not only offers controlled execution time and superior performance but also effectively avoids potential resource leaks and unpredictable program behavior, making it the best practice for ensuring stability in .NET applications under high-concurrency scenarios.

Views 69
.NET Finalizer IDisposable Performance garbage collection performance optimization