Ruby processes accessing the database through ActiveRecord, automatically calculate the connection-pool size for the process based on the concurrency.
Because of the way Ruby on Rails manages database connections,
it is important that we have at
least as many connections as we have threads. While there is a ‘pool’
database.yml, it is not very practical because you need to
maintain it in tandem with the number of application threads. For this
reason, we override the number of allowed connections in the database
connection-pool based on the configured number of application threads.
Gitlab::Runtime.max_threads is the number of user-facing
application threads the process has been configured with. We also have
auxiliary threads that use database connections. As it isn’t
straightforward to keep an accurate count of the number of auxiliary threads as
the application evolves over time, we just add a fixed headroom to the
number of user-facing threads. It is OK if this number is too large
because connections are instantiated lazily.
The connection-pool usage can be seen per environment in the connection-pool saturation dashboard.
If the connection-pool is too small, this would manifest in
ActiveRecord::ConnectionTimeoutErrors from the application. Because we alert
when almost all connections are used, we should know this before
timeouts occur. If this happens we can remediate by setting the
DB_POOL_HEADROOM environment variable to something bigger than the
hardcoded value (10).
At this point, we need to investigate what is using more connections
than we anticipated. To do that, we can use the
gitlab_ruby_threads_running_threads metric. For example,
shows all running threads that connect to the database by their
name. Threads labeled
puma worker or
the threads that define
Gitlab::Runtime.max_threads so those are
accounted for. If there’s more than 10 other threads running, we could
consider raising the default headroom.
For web requests, a connection is obtained from the pool at the first time a database query is made. The connection is returned to the pool after the request completes.
For background jobs, the behavior is very similar. The thread obtains a connection for the first query, and returns it after the job is finished.
This is managed by Rails internally.