18 Tools and Techniques to Improve Rails Application Performance

Database Problems & Tools

# 1 Bullet

• https://github.com/flyerhzm/bullet

# 2 N+1 Control

• https://github.com/palkan/n_plus_one_control

#3 NewRelic, AppSignal, RoRvsWild and other APM systems

These tools offer various features and integrations that can assist you in monitoring and diagnosing N+1 query problems and other performance issues in your Ruby on Rails applications.

Above is the screenshot from AppSignal indicating request having N+1 problem.

#4 PgHero

• https://github.com/ankane/pghero

PgHero is a powerful database optimization web dashboard explicitly designed for PostgreSQL. Founded by Andrew Kane, PgHero offers comprehensive features and insights to help users identify and resolve performance bottlenecks, ensuring their applications run efficiently and smoothly.

One of PgHero's standout features is its real-time dashboard, which gives users a holistic view of their database's performance metrics. This includes information on query execution times, slow queries, database locks, and more. With this dashboard, users can quickly pinpoint areas that require attention and take proactive measures to optimize their database queries and configurations. Additionally, PgHero offers historical query analysis, allowing users to track query performance over time and identify trends or anomalies.

PgHero is distributes as a Rails Engine or Docker image, which seems a better option for me and can be easily added to your Rails application deployed with Kamal as an accessory.

#5 Rails PG Extras

• https://github.com/pawurb/rails-pg-extras

#6 Strong Migrations

• https://github.com/ankane/strong_migrations

#7 Database Validations

• https://github.com/toptal/database_validations

#8 Database Consistency

• https://github.com/djezzzl/database_consistency

Lintering & Audit

#9 RuboCop Performance

• https://docs.rubocop.org/rubocop-performance/cops_performance.html
• https://github.com/rubocop/rubocop-performance

# Performance/Casecmp

# bad
str.downcase == 'abc'
str.upcase.eql? 'ABC'
'abc' == str.downcase
'ABC'.eql? str.upcase
str.downcase == str.downcase

# good
str.casecmp('ABC').zero?
'abc'.casecmp(str).zero?

# Performance/ChainArrayAllocation

# bad
array = ["a", "b", "c"]
array.compact.flatten.map { |x| x.downcase }

# good
array = ["a", "b", "c"]
array.compact!
array.flatten!
array.map! { |x| x.downcase }
array

#10 Fasterer

• https://github.com/DamirSvrtan/fasterer

#11 bundler-leak

• https://github.com/rubymem/bundler-leak

Data Serialization

#12 Panko

• https://github.com/yosiat/panko_serializer

1. Using C extension of OJ library
2. Incremental serialization of Ruby arrays
3. Type casting that does not rely on ActiveRecord
4. Figuring out the metadata, ahead of time

#13 Alba & OJ

• https://github.com/okuramasafumi/alba

#14 GraphQL Performance Tools

• GraphQL Batch https://github.com/Shopify/graphql-batch
• ArLazyPreload https://github.com/DmitryTsepelev/ar_lazy_preload
• GraphQL::PersistedQueries https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries
• GraphQL::FragmentCache https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache

Profiling

#15 Rack Mini Profiler, Stackprof & MemoryProfiler

• https://github.com/MiniProfiler/rack-mini-profiler
• https://github.com/tmm1/stackprof
• https://github.com/SamSaffron/memory_profiler

When I hear about profiling in Rails, I always think about Rack Mini Profiler. This Rack middleware for Ruby web applications enables real-time profiling and performance monitoring. With stackprof it can also provide flamegraphs. I especially love that it is designed to work both in production and development.

By adding memory_profiler gem to your application bundle, you can also do memory profiling for each request directly in your browser, which is really helpful.

Dockerfile optimization

1. Container Size and Efficiency: The size of your Docker container directly affects deployment times, resource consumption, and scalability.
2. Resource Utilization: Docker containers share resources with the host system. An inefficient Dockerfile can lead to excessive resource consumption, causing performance bottlenecks and potential service interruptions.
3. Dependency Management: Docker allows you to package your Rails application and its dependencies together. An optimized Dockerfile defines dependencies explicitly and installs only what's necessary.
4. Reproducibility: Dockerfiles are used to create reproducible environments. An optimized Dockerfile guarantees consistency across development, staging, and production environments.
5. Scalability: When your application needs to scale to handle increased traffic, the efficiency of your Docker containers becomes critical.
6. CI/CD Pipeline Efficiency: An optimized Dockerfile speeds up your continuous integration and continuous deployment (CI/CD) pipeline.
7. Cost Savings: Running containers in the cloud often incurs costs based on resource usage. By optimizing your Docker containers, you can reduce resource utilization, leading to cost savings in terms of infrastructure and cloud services.

#16 Dive

• https://github.com/wagoodman/dive

Caching

#17 Dalli

• https://github.com/petergoldstein/dalli

Tests Performance

#18 Test Prof

• https://github.com/test-prof/test-prof

Conclusions