How we overcame efficiency nightmares in our monolith app – IBM Developer


Subscriber and Subscription Administration (SSM) is the system that funnels orders for IBM SaaS choices provided by way of IBM and third-party marketplaces to the suitable endpoints. This provisions orders for the shoppers and manages their whole subscriber and subscription lifecycle. It handles about 2,000 requests per hour.

SSM is a legacy monolith app. Nevertheless, coping with such a mission-critical software with hundreds of thousands of traces of code generally is a nightmare. Making it extra complicated is the transaction dealing with applied at each smallest service layer unit. To help high-end enterprise use circumstances, there are dozens of composite APIs that SSM helps. These composite APIs internally make calls to the smallest-unit APIs, holding a number of DB connections for a single composite API request.

This ultimately resulted in blasting the DB reminiscence, shedding myriad dwell transactions. You is likely to be asking:

  • Can’t transaction dealing with be applied on the composite API stage fairly than the smallest API unit? No as a result of the info entry layer construction is tightly coupled with the lower-level APIs, and transferring to increased stage would introduce plenty of stale object-state exception circumstances.
  • Can’t the monolith app be damaged down into microservices structure, which is a present market pattern? No as a result of it is a expensive affair when it comes to assets and time; and furthermore, builders had been busy in tending to the above problem, giving no room to assume and make investments time on this method.

It was essential to discover a quick and environment friendly answer to this downside, because it impacted the enterprise. To make issues worse, with SSM being on the core of {the marketplace} ordering movement, each upstream and downstream programs had been considerably impacted. It was additionally troublesome to determine the supply of the issue, whether or not it was on the code, database, or infrastructure layer (for the reason that software is deployed on IBM Cloud). With the crew’s engineering expertise and aggressive debugging, the problem was analyzed.

The journey

Sample Discovery Section

We analyzed the historic efficiency points utilizing an inner monitoring device. This helped determine an enormous variety of calls had been being made to fetch a consumer with many roles or related entitlements, ensuing within the software consuming extra assets and finally inflicting delays for future API calls. Tis was a progressive effort achieved thorough:

  • Grouping the particular APIs within the monitoring device that brought on further load to the appliance.
  • Taking a snapshot of historic knowledge, enabling us to seek out the sample that brought on the efficiency degradation.
  • Creating comparable API units to run in an SSM preproduction setting.

Downside Replica Section

Efficiency load checks had been run on an SSM preproduction setting over a number of weeks at totally different instances of the day. For each run, heap dumps had been collected. Heap dump assortment for evaluation was a bottleneck. The answer was to kill the primary Java course of and duplicate it to an area machine for debugging. Steps to gather the heap dump from IBM Cloud setting:

  • ibmcloud goal --cf -sso
  • ibmcloud cf apps
  • ibmcloud cf ssh <appname>
  • Run - ps -aux (to get the method ID of the operating cf apps)

We then killed the method ID with the -3 choice (don’t use the -9 choice). As soon as the above instructions are fired, you’ll discover core dump beneath the next folder:

       vcap@27854948-c2e2-4bc8-7649-c266:~$ ls -ltr /house/vcap/app/
        complete 5840
        drwxr-xr-x 4 vcap vcap      62 Jul  5 09:50 WEB-INF
        drwxr-xr-x 3 vcap vcap      38 Jul  5 09:50 META-INF
        drwxr-xr-x 2 vcap vcap      26 Jul  5 09:50 jsp
        -rw-r----- 1 vcap vcap 5979538 Jul  5 12:40 javacore.20210705.124041.16.0001.txt

You’ll be able to generate as many core dumps as you need (relying on the investigation).

Subsequent, we copied the distant core dump into an area laptop computer: ibmcloud cf ssh <appname> -c "cat <path of core dump>" to native laptop computer path listing.

After couple of executions, the identical situation was simulated, which gave some confidence that the investigation is heading in the right direction. It was certainly a frightening process to simulate it again and again throughout peak instances.

Downside Evaluation Section

With a number of dumps, REST calls (GET and POST) had been analyzed in depth. This gave insights on the degraded software conduct. The GET calls had been holding the DB connection even after getting the end result set. In between, different incoming requests waited for the DB connections to launch. This sometimes brought on a impasse scenario, ensuing within the general app going into degraded efficiency mode throughout high-traffic instances, leading to a crash. As the next screenshot reveals, 75 threads in "at com/mchange/v2/resourcepool/BasicResourcePool.awaitAvailable( Code))" had been awaiting connection from pool.

Screenshot shows 75 threads waiting for connection

Resolution Section

Based mostly on the evaluation, the commit mechanism of the GET calls was modified from autoCommit = False to True. This releases the connection instantly when the end result set is fetched vs. holding the it till the tip of the transaction.

Screenshot shows releasing the connection

We fine-tuned the DB connection pool dimension for optimizing the connections between the appliance and knowledge layer. We elevated ibernate.c3p0.max_size from 125 to 250 to create further DB connections within the DB connection pool. We additionally lowered hibernate.c3p0.idle_test_period from 120 to 60 (time for which the connection may be idle earlier than releasing).

Screenshot shows reduction of hibernate time

The mixed method above resulted in ~80% enchancment within the response time for all APIs.

Bar charts show improvement in response time for all APIs

The efficiency enchancment was helpful and had a optimistic influence on the API shoppers. The journey was tougher, however the discovery and studying made the appliance and the crew extra resilient.


Thanks to Anil Sharma for the evaluation on the database and Bhakta for sharing experience on heap dumps. And particular because of Nalini V. for guiding us on this journey.


Leave a Reply

Your email address will not be published. Required fields are marked *