N+1 detection tools in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Detecting N+1 queries with Bullet gem

Given a Rails app using the Bullet gem, what will Bullet report when rendering a view that loads Post records and then accesses each post's comments without eager loading?

Ruby on Rails

posts = Post.all
posts.each do |post|
  post.comments.each do |comment|
    puts comment.body
  end
end

A Bullet will report a syntax error due to missing eager loading.

B Bullet will not report any warnings because Post.all loads all posts at once.

C Bullet will report an N+1 query warning because comments are accessed without eager loading.

D Bullet will report a performance warning unrelated to N+1 queries.

💡 Hint

Think about what happens when you access an association inside a loop without eager loading.

Bullet detects when your code triggers multiple database queries inside loops due to missing eager loading. Here, accessing post.comments inside the loop causes an N+1 query problem.

📝 Syntax

intermediate

Correct usage of includes to avoid N+1

Which option correctly uses includes to avoid N+1 queries when loading posts and their comments?

Ruby on Rails

posts = Post.???
posts.each do |post|
  post.comments.each do |comment|
    puts comment.body
  end
end

A select(:comments)

B includes(:comments)

C preload(:comments).where('comments.count > 0')

D joins(:comments)

💡 Hint

Which method loads associated records to prevent extra queries?

includes(:comments) loads posts and their comments in two queries, preventing N+1. joins only joins tables but does not eager load. select changes selected columns. preload is valid but the added where clause is invalid here.

🔧 Debug

advanced

Identifying cause of false positive N+1 detection

Using the Bullet gem, you get an N+1 warning on user.profile even though you used includes(:profile). What is the most likely cause?

Ruby on Rails

users = User.includes(:profile).where(active: true)
users.each do |user|
  puts user.profile.bio
end

A The <code>profile</code> association uses a custom SQL that disables eager loading.

B You forgot to call <code>references(:profile)</code> along with <code>includes</code>.

C The <code>profile</code> association is defined with <code>optional: true</code>, causing Bullet to misdetect.

D Bullet cannot detect N+1 queries on <code>has_one</code> associations.

💡 Hint

Think about how custom SQL in associations affects eager loading.

If the association uses a custom SQL query or scope that disables eager loading, Bullet may report false positives because the data is not preloaded as expected.

🧠 Conceptual

advanced

Understanding Skylight's N+1 detection approach

How does Skylight detect N+1 queries in a Rails application?

A By scanning the source code for missing <code>includes</code> calls in ActiveRecord queries.

B By monitoring CPU usage spikes during database calls.

C By requiring manual annotations in the code to mark potential N+1 spots.

D By analyzing the number of similar SQL queries executed during a single request and flagging repeated queries on associations.

💡 Hint

Think about how a tool can detect repeated queries dynamically.

Skylight tracks SQL queries during requests and identifies patterns where many similar queries are executed repeatedly, indicating N+1 problems.

❓ state_output

expert

Output of Rack Mini Profiler on N+1 queries

Given this Rails controller code, what output will Rack Mini Profiler show regarding database queries?

def index
  @users = User.all
  @users.each do |user|
    user.posts.each do |post|
      puts post.title
    end
  end
end

A It will show 1 query for users and multiple queries for posts, indicating an N+1 problem.

B It will show a single optimized query joining users and posts.

C It will show no database queries because data is cached.

D It will show a syntax error in the controller code.

💡 Hint

Consider how accessing associations inside loops affects query count.

Without eager loading, accessing user.posts inside a loop triggers one query per user, causing multiple queries and an N+1 problem visible in Rack Mini Profiler.

Practice

1. What is the main purpose of N+1 detection tools in a Rails application?

easy

A. To style the user interface

B. To add new features automatically

C. To find repeated database queries that slow down the app

D. To manage user authentication

Solution

1. Step 1: Understand what N+1 problem means

   The N+1 problem happens when the app makes many repeated database queries instead of one efficient query.

2. Step 2: Identify the role of detection tools

   N+1 detection tools help find these repeated queries so developers can fix them and speed up the app.

3. Final Answer:

   To find repeated database queries that slow down the app -> Option C

4. Quick Check:

   N+1 detection = find repeated queries [OK]

Hint: N+1 tools catch repeated queries slowing your app [OK]

Common Mistakes:

• Thinking N+1 tools add features
• Confusing with UI styling tools
• Assuming they handle authentication

2. Which gem is commonly used in Rails to detect N+1 query problems?

easy

A. Devise

B. Sidekiq

C. Puma

D. Bullet

Solution

1. Step 1: Recall popular Rails gems for N+1 detection

   Bullet gem is well-known for detecting N+1 queries and unused eager loading.

2. Step 2: Differentiate from other gems

   Devise handles authentication, Puma is a server, Sidekiq manages background jobs, so they don't detect N+1 queries.

3. Final Answer:

   Bullet -> Option D

4. Quick Check:

   Bullet gem = N+1 detection [OK]

Hint: Bullet gem is for N+1 detection in Rails [OK]

Common Mistakes:

• Choosing Devise for N+1 detection
• Confusing server or job gems with detection tools
• Not knowing Bullet gem purpose

3. Given this Rails code snippet, what will Bullet gem detect?

posts = Post.all
posts.each do |post|
  puts post.comments.count
end

medium

A. N+1 query problem because comments are queried inside the loop

B. Syntax error in the code

C. No issues, code is efficient

D. Bullet will detect missing authentication

Solution

1. Step 1: Analyze the code for database queries

   The code loads all posts, then inside the loop queries comments count for each post separately.

2. Step 2: Understand what Bullet detects

   Bullet detects N+1 queries, which happen here because each post triggers a separate query for comments.

3. Final Answer:

   N+1 query problem because comments are queried inside the loop -> Option A

4. Quick Check:

   Loop querying associations = N+1 problem [OK]

Hint: Loop querying associations causes N+1 detected by Bullet [OK]

Common Mistakes:

• Thinking code is efficient without eager loading
• Confusing Bullet with syntax checker
• Assuming Bullet checks authentication

4. You see Bullet gem warnings about N+1 queries in your Rails app. Which fix will solve this problem?

posts = Post.all
posts.each do |post|
  puts post.comments.count
end

medium

A. Remove the loop and print posts only

B. Add .includes(:comments) to the query

C. Add .order(:created_at) to the query

D. Change post.comments.count to post.comments.first

Solution

1. Step 1: Identify the cause of N+1 queries

   Each post triggers a separate query for comments count, causing many queries.

2. Step 2: Apply eager loading to fix N+1

   Using .includes(:comments) loads all comments with posts in one query, preventing repeated queries.

3. Final Answer:

   Add .includes(:comments) to the query -> Option B

4. Quick Check:

   Eager load associations with includes to fix N+1 [OK]

Hint: Use includes(:association) to fix N+1 queries [OK]

Common Mistakes:

• Thinking ordering fixes N+1
• Removing loop doesn't fix data needed
• Changing count to first doesn't fix queries

5. In a Rails app using Bullet gem, you notice it reports N+1 queries on nested associations like user.posts.comments. How can you fix this efficiently?

hard

A. Use .includes(posts: :comments) when loading users

B. Load users, posts, and comments separately in different queries

C. Remove comments from the view to avoid queries

D. Use .joins(:posts, :comments) without includes

Solution

1. Step 1: Understand nested N+1 queries

   Accessing user.posts.comments triggers queries for posts and then comments for each post, causing nested N+1 problems.

2. Step 2: Use nested eager loading

   Using .includes(posts: :comments) loads users with posts and their comments in minimal queries, fixing nested N+1.

3. Final Answer:

   Use .includes(posts: :comments) when loading users -> Option A

4. Quick Check:

   Nested includes fix nested N+1 queries [OK]

Hint: Use nested includes for nested associations to fix N+1 [OK]

Common Mistakes:

• Loading associations separately causing more queries
• Removing data instead of fixing queries
• Using joins without includes misses eager loading