Imagine having a tool that can automatically detect if you are using JPA and Hibernate properly.
Hypersistence Optimizer is that tool!
When I started working on enterprise projects we were using J2EE and the pooling data source was provided by the application server.
Scaling up meant buying more powerful hardware to support the increasing request demand. The vertical scaling meant that for supporting more requests, we would have to increase the connection pool size accordingly.
Our recent architectures shifted from scaling up to scaling out. So instead of having one big machine hosting all our enterprise services, we now have a distributed service network.
Deploying a batch service doesn’t affect the front services
If one service goes down it won’t affect the rest
Database connection provisioning
But all those services end up calling the database and that’s always done through a database connection. A database server can offer only a limited number of concurrent connections, so connection provisioning is mandatory.
The current connection pooling solutions offer limited monitoring and failover support. This is what we’ve been struggling with lately and that’s why I decided to build FlexyPool.
There’s a new guy in town
FlexyPool is a data source proxy offering better monitoring and failover for the following connection pools:
We concluded that sizing connection pools are not an upfront design decision. In large enterprise systems, you need adaptability and monitoring is the first step to taking the right decisions.
This indicates how many connections are being used at once.
This indicates how many connection are being requested at once.
A time histogram of the target data source connection acquire interval.
The lease time is the duration between the moment a connection is acquired and the time it gets released.
A histogram of the target pool size.
A time histogram of the total connection acquire interval.
A histogram of the pool size overflowing.
A histogram of the retry attempts number.
When all pooled connections are being used, a new connection acquires request will wait for a limited amount of time before giving up. This prevents system overloading but to avoid rejecting connection requests you have to properly configure the connection pool size. You will also have to consider traffic spikes and take into consideration all other services competing for the limited amount of database connections. The monitored data can provide you with a better insight into connection usage so you’ll be better equipped when deciding the proper pool size.
FlexyPool was designed to be reactive, so it can better adapt to traffic spikes. For this, it offers a configurable failover strategy mechanism.
A Strategy is a connection acquiring safety mechanisms, a resort that’s called when a connection is not successfully fetched from the target Connection Pool.
FlexyPool comes with the following default strategies
Increment Pool On Timeout
This strategy will increment the target connection pool maximum size on connection acquire timeout.
The connection pool has a minimum size and on demand it can grow up to its maximum size. The overflow is a buffer of extra connections allowing the connection pool to grow beyond its initial maximum size. Whenever a connection acquire timeout is detected, the current request won’t fail if the pool hasn’t grown to its maximum overflow size.
This strategy is useful for those connection pools lacking a connection acquiring retry mechanism
If you enjoyed this article, I bet you are going to love my Book and Video Courses as well.
My next article will demonstrate how FlexyPool can assist you finding the right pool size.
10 000readers have found this blog worth following!
If you subscribeto my newsletter, you'll get:
A free sampleof my Video Course about running Integration tests at warp-speed using Docker and tmpfs
3 chapters from mybook, High-Performance Java Persistence,
Based on my book, High-Performance Java Persistence, this workshop teaches you various data access performance optimizations from JDBC, to JPA, Hibernate and jOOQ for the major rational database systems (e.g. Oracle, SQL Server, MySQL and PostgreSQL).