Contact us anytime to know more — Amit A., Founder & COO CISIN
Understand The Components Of Your Application
Dependency Injection has become the go-to technique in modern applications, which often contain multiple embedded components that need optimizing to make them highly performant and functional.
To have an optimized application, each part must be carefully tuned, and with each of them comes its performance optimization challenge.
An Application may include
- CRUD operations for RDBMS and No SQL DBs
- APIs to process business logic using various design patterns.
- Caching.
- Async processing.
- Batch Processing
- Data processing on a schedule
There are many others.
Performance Optimization Approaches
Iterative performance optimization includes conducting multiple load tests on applications to gain insight into their behavior, with particular attention paid to their most common components and ways they may be improved.
Optimizing SQL Database Most cloud providers offer performance monitoring tools to monitor components' performance metrics.
Microsoft Azure provides an intelligent performance tool that provides insight into query performance as well as optimizing them through different recommendations - some examples being:
- You can add or remove the indexes if necessary.
- Reduces resource consumption by using a metricized query for caching plans.
Memory Utilization Review
Before considering an application production-ready, memory usage analysis must take place to ensure no leaks might degrade performance and affect user experience.
Take a snapshot of the heap while it is under heavy load in your application's development environment.
VisualVM is an efficient tool that enables us to access applications and see their memory consumption remotely. To use VisualVM successfully on our servers, firewall configuration changes may need to be made for remote application access.
- Heap Utilization Review
- VisualVM's VisualGC plugin allows you to view JVM heap usage. The graph shows how memory usage changes over time. Both slopes indicate that memory usage is good.
The use of the entire Eden space above shows that there is a better allocation and heap usage.
- Memory Leaks
- Memory leaks are one of the main culprits in degrading performance, which may lead to the crash of an application.
- VisualVM offers memory and CPU samplers and profilers. Memory profilers can provide data about the most resilient objects and indicate memory leaks. More research needs to be done to determine why objects survive garbage collection cycles. However, any objects that have survived for a long time and are not required to do so will likely lead to memory leaks.
- Code Inspect IntelliJ
- IntelliJ is an excellent tool for analyzing code to identify memory issues and other performance problems. We often fail to realize that collections have default allocated memory, and excessive use of collections, even with fewer data within them, can result in higher memory usage. IntelliJ's Inspect Code tool provides recommendations on how to increase performance.
- We often fail to initialize collection sizes. It can result in higher GCs as a result of memory allocation failure.
- Anonymous class is another issue to address. Using an anonymous class poses the risk that dangling references can lead to memory leaks and cannot be garbage collected.
- Before committing any code, reviewing all such recommendations regarding performance and memory is essential.
- GC Logs
- The garbage collection logs can help identify issues with memory, JVM heap usage, and memory leaks.
- When building applications, we fail to recognize the Young Gen and Old Gen memory allocations for JVM. JVM always sets this to default.
- JVM offers a way of tweaking the ratios for the allocations to Young Gen and Old Gen memory using the -XX flags. The flags help better to utilize the Young Gen and Old Gen space when an application requires more space for the young generation due to its inherent complexity.
- The use of the term "thread soft."
- Soft References are used by Object Mappers, Async thread processing, and Object mappers to retrieve Objects faster during the request processing. Soft Reference Objects can stay in memory longer, surviving even significant GCs. The GC is only performed when memory usage reaches an acceptable threshold. It can cause application crashes if you are processing large JSON documents using Object Mappers or if there is significant async work. Two ways can be used to resolve this problem --
- -- Disable the Feature USE_THREAD_LOCAL_FOR_BUFFER_RECYCLING in JsonFactory of Object Mapper.
- -- Tweak the value for JVM Flag: -XX: SoftRefLRUPolicyMSPerMB.
- Caching
- It is a widely-used concept that can store static data for quicker retrieval. There are many caching libraries, or you can use static objects. It is essential to understand the differences between these and choose the best way to cache the data.
- Memory leakage is one of the main drawbacks of using static caches that are never refreshed. The cache should have eviction/refresh criteria so we don't hold on to objects that are outlived by the application.
CPU Utilization Review
Every line of code written into any application is compiled and run by the CPU; therefore, applications should use it optimally to create resources like Threads/Executors/GCs/Computations, etc.
Below are a few things to keep in mind when developing an application or analyzing CPU performance:
- Async Processing
- When creating or using algorithms to solve any application, we must know when to use async and parallel processing logic.
- It is best to keep async processes out of the transactional context since they can cause data consistency issues when used in transactional processing. Async processing can handle any IO-intensive operations, such as calling services dependent on each other or retrieving data from SQL outside the transactional context.
- It is best to create executors at the start of an application and then use them for async processes. The creation of executors requires a lot of CPU power. Creating them for each request can severely impact CPU performance.
- How to add an executor in a Spring Boot application
The executor Service we employ provides MDC functionality that enables us to transfer tracking IDs and MDC context from main threads onto executor threads for reuse in async MDCs, so the thread should be deleted immediately.
Hence, the object becomes eligible for garbage collection (GC).
- Bulk/Batch Processing
- Batch processing is not limited to DB data insertion (SQL or NoSQL). Bulk processing was one of our experiments that yielded a positive result. We used it when a request contained 'Collection of Data. The bulk data processing is done using Collections, and we persist the data to DBs/Batches.
- It is recommended to perform bulk processing when using JDBC-prepared statements in the DAO layer. This can reduce processing time by a great deal. Spring JPA provides interfaces to persist data in large quantities for SQL DBs.
- Microsoft Azure Cosmos offers a bulk executor that allows you to efficiently import multiple documents into Cosmos DB with a multi-master setup.
- Analysis of the processing time for each API step
- It is essential to understand the processing time of each request at every step. It gives insight into the time spent by each dependent service, calls to data sources, and in-memory computations. These data can be used to analyze code minutely and optimize code for the SLAs. This helps devise new strategies for processing requests, such as making service calls independently in async and much higher than necessary.
Read More: Optimizing Software Applications with Cloud Computing
Additional Performance Measures
- Diagnostic Tools
- Microsoft Azure offers diagnostic tools that measure the memory and CPU performance in a WebApp. The data provided by this tool can help during the soak tests.
- Cost optimization measures
- The cost of developing an application is a fundamental aspect. Every component adds costs. The performance improvements directly contribute to more efficient cost utilization.
- The costing of components of the platform should be performed to determine the resources required to meet the TPS and SLAs expected in a production setting.
- Monitoring Tools
- Each cloud service offers multiple tools to monitor the PaaS component. These can be used for understanding performance metrics like p95 of requests, p90, and p99, garbage collection metrics, heap statistics, etc.
- You can integrate our tools with others like Prometheus and Grafana.
- Tests of load and soak
- To analyze performance, it is necessary to perform a load/stress test on applications. It helps identify the areas for improvement and gaps, as described above, so that the application can be optimized.
- We can run stress/performance tests for extended periods using soak testing. It is a great way to uncover unidentified factors that could lead to long-term performance degradation.
- Before an application can be considered production-ready, it must pass both load and soak testing.
- Jmeter is a tool that can help us write scripts to test an application and meet TPS expectations.
- Distributed Performance Test
- Network latency is an important performance measure. We must deploy services in the World Wide Web age to not let geographical borders define our end user's experience. It is recommended to run distributed performance testing so we can know our clientele and optimize network hops if necessary. We should also have distributed deployment application strategies in place so the latencies on the networks are minimized and don't affect the user experience.
- SLAs/Response time requirements
- Response time defines the behavior of a system from end to end and the end user's experience. It is, therefore, essential to specify SLAs/Response Time Requirements for each service interface.
- We measure SLAs in our system by the p95 response time for each interface. This should be below 500 ms during the periods of stress and soak tests. The orchestration service for the interface should expect to receive all responses within 500 ms to deliver the required data in under a second.
- Calculation of Throughput
- Throughput or TPS(TransactionsPerSecond)/RPS(RequestsPerSecond) measures the number of requests a given application server can handle within 1 second. There are two ways to calculate or achieve throughput.
- If we know the number of transactions a system must handle within a specific timeframe, we can calculate the TPS of each interface.
- Suppose we don't know the number of transactions a system must process in a specific period. In that case, we can make an assumption based on the realistic requirements of the application and then go back to calculate the TPS of each interface.
- The worst-case scenario for both scenarios is to make an assumption about peak traffic and adjust the requests based on that assumption.
- It is important to always perform performance testing by considering the worst-case scenarios of requests and amortizing them to meet an average TPS requirement.
- Resource Provisioning
- Performance testing and resource provisioning go hand-in-hand for PaaS component components. Resource provisioning will increase as TPS requirements continue to rise. After specific optimization, any application will reach a maximum and should be horizontally scaled to meet the SLA and TPS needs. The CPU and memory are two of the most critical factors in horizontal scaling. Ideally, an instance shouldn't exceed 60% CPU and 70% Memory utilization. This number may be debatable, but it ensures any spike in CPU or Memory utilization due to spikes in requests will be managed until the auto-scaling of resources occurs, and the additional load is handled before the resources become available.
How To Optimize Your Web App Performance
Underperforming web application performance can have serious repercussions for businesses. You could experience decreased productivity, or users could have an unpleasant experience on your site and leave.
Many organizations place great value on optimizing the performance of web apps and sites.
Optimizing web application performance involves tracking, analyzing, and improving app performance in multiple ways.
For instance, code modifications or restricting others from embedding images could all contribute to greater overall app efficiency - these tips will help troubleshoot an underperforming web app and get it up and running as efficiently as possible!
Use Key Metrics
Utilize critical metrics to locate areas of high usage and enhance targeting quickly. Tracking key metrics makes finding bottlenecks in your system much simpler - then, once identified, you'll know where your efforts need to focus rather than trying to optimize without clear direction.
Use a Content Delivery Network to reduce latency
CDNs (Content Delivery Networks) can help your organization increase bandwidth and accelerate asset delivery while decreasing access latency.
CDNs consist of nodes that store copies of content to fulfill end-user content requests quickly.
Consider Your Caching
Your website's performance can be enhanced by caching static files closer to visitors' browsers; your websites will load faster as this reduces traffic on primary servers and keeps loads under control.
Bundle Your Files
Optimizing is all about decreasing the number of files and optimizing them to boost the performance of a web app, such as minifying or bundling them together to increase performance.
One option to reduce file count and size includes eliminating unneeded characters such as newline characters and whitespace characters from JavaScript CSS HTML or block delimiters and comments - minification can speed up website load time since the browser needs less code.
Improve Your Images
Images can reduce performance on web applications significantly. They should generally be optimized and made smaller whenever possible; both.png and.jpeg files can easily be reduced.
Upload your pictures at scale instead of depending on CSS for their sizing needs.
Update Your Web Server
Optimization of web apps begins on the server side, or how quickly requests can be fulfilled by their respective servers.
Therefore, keeping current with server patches and security updates for optimal function and performance. Any late updates could leave security holes that compromise efficiency and reduce performance.
Reducing HTTP Requests
HTTP requests (Hypertext transfer protocol) allow browsers to gather data off servers, making the webpage take longer to load as more HTTP requests are made.
You should avoid creating unnecessary HTTP requests that would slow page load times by writing less code and forgoing any third-party frameworks that increase HTTP request frequency.
You Can Use Logs To Monitor Performance
Logs allow web application administrators to monitor performance in real-time and more easily identify and solve critical issues within an application when you can view logs directly in real-time.
Select The Right Tools For Web App Performance Optimization
Optimize performance with software designed to monitor servers and provide metrics. Discover actionable insights for improving environments through targeted solutions such as AppOptics from SolarWinds; it monitors the server side of critical applications while guaranteeing their services are performing above expectations.
With over 150 preloaded plugins and integrations, AppOptics makes monitoring critical applications quick and simple.
Track key metrics like CPU usage, memory utilization, and disk performance; create custom metrics; monitor errors on websites and response times; and drill into individual code lines that might contribute to performance issues.
AppOptics' customizable dashboard makes tracking all of your key performance indicators simple. Furthermore, AppOptics includes alerting features that notify you immediately when a problem or outage arises, allowing for swift actions and reduced impact on end users.
SolarWinds Loggly (r) is an intuitive log solution you can combine with AppOptics for web performance optimization.
Loggly's event logs let you monitor the server in real-time and identify potential application problems quickly, while manually gathering logs would likely become impossible. Loggly centralizes and analyzes relevant logs so you have a continuous view of web applications; combined, they make for a powerful web-based monitoring solution!
Wrapping Up
There are various methods for improving an application's performance. This analysis only addresses mitigating risks and optimizing resource usage/code.
As application developers, we must be mindful of acceptable tradeoffs; otherwise, they could become inevitable and unacceptable compromises.
