bullet-6.1.0/ 0000755 0001750 0001750 00000000000 13704275356 014241 5 ustar debbiecocoa debbiecocoa bullet-6.1.0/Gemfile.mongoid-4.0 0000644 0001750 0001750 00000000426 13704275356 017470 0 ustar debbiecocoa debbiecocoa source "https://rubygems.org"
gemspec
gem 'rails', '~> 4.0.0'
gem 'sqlite3', platforms: [:ruby]
gem 'activerecord-jdbcsqlite3-adapter', platforms: [:jruby]
gem 'mongoid', '~> 4.0.0'
gem "rspec"
platforms :rbx do
gem 'rubysl', '~> 2.0'
gem 'rubinius-developer_tools'
end
bullet-6.1.0/Guardfile 0000644 0001750 0001750 00000000516 13704275356 016070 0 ustar debbiecocoa debbiecocoa # A sample Guardfile
# More info at https://github.com/guard/guard#readme
guard 'rspec', version: 2, all_after_pass: false, all_on_start: false, cli: '--color --format nested --fail-fast' do
watch(%r{^spec/.+_spec\.rb$})
watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
watch('spec/spec_helper.rb') { 'spec' }
end
bullet-6.1.0/README.md 0000644 0001750 0001750 00000034740 13704275356 015530 0 ustar debbiecocoa debbiecocoa # Bullet
[](http://badge.fury.io/rb/bullet)
[](http://travis-ci.org/flyerhzm/bullet)
[](https://awesomecode.io/repos/flyerhzm/bullet)
[](http://coderwall.com/flyerhzm)
The Bullet gem is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries), when you're using eager loading that isn't necessary and when you should use counter cache.
Best practice is to use Bullet in development mode or custom mode (staging, profile, etc.). The last thing you want is your clients getting alerts about how lazy you are.
Bullet gem now supports **activerecord** >= 4.0 and **mongoid** >= 4.0.
If you use activerecord 2.x, please use bullet <= 4.5.0
If you use activerecord 3.x, please use bullet < 5.5.0
## External Introduction
* [http://railscasts.com/episodes/372-bullet](http://railscasts.com/episodes/372-bullet)
* [http://ruby5.envylabs.com/episodes/9-episode-8-september-8-2009](http://ruby5.envylabs.com/episodes/9-episode-8-september-8-2009)
* [http://railslab.newrelic.com/2009/10/23/episode-19-on-the-edge-part-1](http://railslab.newrelic.com/2009/10/23/episode-19-on-the-edge-part-1)
* [http://weblog.rubyonrails.org/2009/10/22/community-highlights](http://weblog.rubyonrails.org/2009/10/22/community-highlights)
## Install
You can install it as a gem:
```
gem install bullet
```
or add it into a Gemfile (Bundler):
```ruby
gem 'bullet', group: 'development'
```
**Note**: make sure `bullet` gem is added after activerecord (rails) and
mongoid.
## Configuration
Bullet won't do ANYTHING unless you tell it to explicitly. Append to
`config/environments/development.rb` initializer with the following code:
```ruby
config.after_initialize do
Bullet.enable = true
Bullet.sentry = true
Bullet.alert = true
Bullet.bullet_logger = true
Bullet.console = true
Bullet.growl = true
Bullet.xmpp = { :account => 'bullets_account@jabber.org',
:password => 'bullets_password_for_jabber',
:receiver => 'your_account@jabber.org',
:show_online_status => true }
Bullet.rails_logger = true
Bullet.honeybadger = true
Bullet.bugsnag = true
Bullet.airbrake = true
Bullet.rollbar = true
Bullet.add_footer = true
Bullet.skip_html_injection = false
Bullet.stacktrace_includes = [ 'your_gem', 'your_middleware' ]
Bullet.stacktrace_excludes = [ 'their_gem', 'their_middleware', ['my_file.rb', 'my_method'], ['my_file.rb', 16..20] ]
Bullet.slack = { webhook_url: 'http://some.slack.url', channel: '#default', username: 'notifier' }
end
```
The notifier of Bullet is a wrap of [uniform_notifier](https://github.com/flyerhzm/uniform_notifier)
The code above will enable all of the Bullet notification systems:
* `Bullet.enable`: enable Bullet gem, otherwise do nothing
* `Bullet.alert`: pop up a JavaScript alert in the browser
* `Bullet.bullet_logger`: log to the Bullet log file (Rails.root/log/bullet.log)
* `Bullet.console`: log warnings to your browser's console.log (Safari/Webkit browsers or Firefox w/Firebug installed)
* `Bullet.growl`: pop up Growl warnings if your system has Growl installed. Requires a little bit of configuration
* `Bullet.xmpp`: send XMPP/Jabber notifications to the receiver indicated. Note that the code will currently not handle the adding of contacts, so you will need to make both accounts indicated know each other manually before you will receive any notifications. If you restart the development server frequently, the 'coming online' sound for the Bullet account may start to annoy - in this case set :show_online_status to false; you will still get notifications, but the Bullet account won't announce it's online status anymore.
* `Bullet.rails_logger`: add warnings directly to the Rails log
* `Bullet.honeybadger`: add notifications to Honeybadger
* `Bullet.bugsnag`: add notifications to bugsnag
* `Bullet.airbrake`: add notifications to airbrake
* `Bullet.rollbar`: add notifications to rollbar
* `Bullet.sentry`: add notifications to sentry
* `Bullet.add_footer`: adds the details in the bottom left corner of the page. Double click the footer or use close button to hide footer.
* `Bullet.skip_html_injection`: prevents Bullet from injecting XHR into the returned HTML. This must be false for receiving alerts or console logging.
* `Bullet.stacktrace_includes`: include paths with any of these substrings in the stack trace, even if they are not in your main app
* `Bullet.stacktrace_excludes`: ignore paths with any of these substrings in the stack trace, even if they are not in your main app.
Each item can be a string (match substring), a regex, or an array where the first item is a path to match, and the second
item is a line number, a Range of line numbers, or a (bare) method name, to exclude only particular lines in a file.
* `Bullet.slack`: add notifications to slack
* `Bullet.raise`: raise errors, useful for making your specs fail unless they have optimized queries
Bullet also allows you to disable any of its detectors.
```ruby
# Each of these settings defaults to true
# Detect N+1 queries
Bullet.n_plus_one_query_enable = false
# Detect eager-loaded associations which are not used
Bullet.unused_eager_loading_enable = false
# Detect unnecessary COUNT queries which could be avoided
# with a counter_cache
Bullet.counter_cache_enable = false
```
## Whitelist
Sometimes Bullet may notify you of query problems you don't care to fix, or
which come from outside your code. You can whitelist these to ignore them:
```ruby
Bullet.add_whitelist :type => :n_plus_one_query, :class_name => "Post", :association => :comments
Bullet.add_whitelist :type => :unused_eager_loading, :class_name => "Post", :association => :comments
Bullet.add_whitelist :type => :counter_cache, :class_name => "Country", :association => :cities
```
If you want to skip bullet in some specific controller actions, you can
do like
```ruby
class ApplicationController < ActionController::Base
around_action :skip_bullet, if: -> { defined?(Bullet) }
def skip_bullet
previous_value = Bullet.enable?
Bullet.enable = false
yield
ensure
Bullet.enable = previous_value
end
end
```
## Log
The Bullet log `log/bullet.log` will look something like this:
* N+1 Query:
```
2009-08-25 20:40:17[INFO] N+1 Query: PATH_INFO: /posts; model: Post => associations: [comments]·
Add to your finder: :include => [:comments]
2009-08-25 20:40:17[INFO] N+1 Query: method call stack:·
/Users/richard/Downloads/test/app/views/posts/index.html.erb:11:in `_run_erb_app47views47posts47index46html46erb'
/Users/richard/Downloads/test/app/views/posts/index.html.erb:8:in `each'
/Users/richard/Downloads/test/app/views/posts/index.html.erb:8:in `_run_erb_app47views47posts47index46html46erb'
/Users/richard/Downloads/test/app/controllers/posts_controller.rb:7:in `index'
```
The first two lines are notifications that N+1 queries have been encountered. The remaining lines are stack traces so you can find exactly where the queries were invoked in your code, and fix them.
* Unused eager loading:
```
2009-08-25 20:53:56[INFO] Unused eager loadings: PATH_INFO: /posts; model: Post => associations: [comments]·
Remove from your finder: :include => [:comments]
```
These two lines are notifications that unused eager loadings have been encountered.
* Need counter cache:
```
2009-09-11 09:46:50[INFO] Need Counter Cache
Post => [:comments]
```
## Growl, XMPP/Jabber and Airbrake Support
see [https://github.com/flyerhzm/uniform_notifier](https://github.com/flyerhzm/uniform_notifier)
## Important
If you find Bullet does not work for you, *please disable your browser's cache*.
## Advanced
### Work with ActiveJob
Include `Bullet::ActiveJob` in your `ApplicationJob`.
```ruby
class ApplicationJob < ActiveJob::Base
include Bullet::ActiveJob if Rails.env.development?
end
```
### Work with other background job solution
Use the Bullet.profile method.
```ruby
class ApplicationJob < ActiveJob::Base
around_perform do |_job, block|
Bullet.profile do
block.call
end
end
end
```
### Work with sinatra
Configure and use `Bullet::Rack`
```ruby
configure :development do
Bullet.enable = true
Bullet.bullet_logger = true
use Bullet::Rack
end
```
### Run in tests
First you need to enable Bullet in test environment.
```ruby
# config/environments/test.rb
config.after_initialize do
Bullet.enable = true
Bullet.bullet_logger = true
Bullet.raise = true # raise an error if n+1 query occurs
end
```
Then wrap each test in Bullet api.
```ruby
# spec/rails_helper.rb
if Bullet.enable?
config.before(:each) do
Bullet.start_request
end
config.after(:each) do
Bullet.perform_out_of_channel_notifications if Bullet.notification?
Bullet.end_request
end
end
```
## Debug Mode
Bullet outputs some details info, to enable debug mode, set
`BULLET_DEBUG=true` env.
## Contributors
[https://github.com/flyerhzm/bullet/contributors](https://github.com/flyerhzm/bullet/contributors)
## Demo
Bullet is designed to function as you browse through your application in development. To see it in action,
you can visit [https://github.com/flyerhzm/bullet_test](https://github.com/flyerhzm/bullet_test) or
follow these steps to create, detect, and fix example query problems.
1\. Create an example application
```
$ rails new test_bullet
$ cd test_bullet
$ rails g scaffold post name:string
$ rails g scaffold comment name:string post_id:integer
$ bundle exec rake db:migrate
```
2\. Change `app/model/post.rb` and `app/model/comment.rb`
```ruby
class Post < ActiveRecord::Base
has_many :comments
end
class Comment < ActiveRecord::Base
belongs_to :post
end
```
3\. Go to `rails c` and execute
```ruby
post1 = Post.create(:name => 'first')
post2 = Post.create(:name => 'second')
post1.comments.create(:name => 'first')
post1.comments.create(:name => 'second')
post2.comments.create(:name => 'third')
post2.comments.create(:name => 'fourth')
```
4\. Change the `app/views/posts/index.html.erb` to produce a N+1 query
```
<% @posts.each do |post| %>
| <%= post.name %> |
<%= post.comments.map(&:name) %> |
<%= link_to 'Show', post %> |
<%= link_to 'Edit', edit_post_path(post) %> |
<%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %> |
<% end %>
```
5\. Add the `bullet` gem to the `Gemfile`
```ruby
gem "bullet"
```
And run
```
bundle install
```
6\. enable the Bullet gem with generate command
```
bundle exec rails g bullet:install
```
7\. Start the server
```
$ rails s
```
8\. Visit `http://localhost:3000/posts` in browser, and you will see a popup alert box that says
```
The request has unused preload associations as follows:
None
The request has N+1 queries as follows:
model: Post => associations: [comment]
```
which means there is a N+1 query from the Post object to its Comment association.
In the meantime, there's a log appended into `log/bullet.log` file
```
2010-03-07 14:12:18[INFO] N+1 Query in /posts
Post => [:comments]
Add to your finder: :include => [:comments]
2010-03-07 14:12:18[INFO] N+1 Query method call stack
/home/flyerhzm/Downloads/test_bullet/app/views/posts/index.html.erb:14:in `_render_template__600522146_80203160_0'
/home/flyerhzm/Downloads/test_bullet/app/views/posts/index.html.erb:11:in `each'
/home/flyerhzm/Downloads/test_bullet/app/views/posts/index.html.erb:11:in `_render_template__600522146_80203160_0'
/home/flyerhzm/Downloads/test_bullet/app/controllers/posts_controller.rb:7:in `index'
```
The generated SQL is:
```
Post Load (1.0ms) SELECT * FROM "posts"
Comment Load (0.4ms) SELECT * FROM "comments" WHERE ("comments".post_id = 1)
Comment Load (0.3ms) SELECT * FROM "comments" WHERE ("comments".post_id = 2)
```
9\. To fix the N+1 query, change `app/controllers/posts_controller.rb` file
```ruby
def index
@posts = Post.includes(:comments)
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @posts }
end
end
```
10\. Refresh `http://localhost:3000/posts`. Now there's no alert box and nothing new in the log.
The generated SQL is:
```
Post Load (0.5ms) SELECT * FROM "posts"
Comment Load (0.5ms) SELECT "comments".* FROM "comments" WHERE ("comments".post_id IN (1,2))
```
N+1 query fixed. Cool!
11\. Now simulate unused eager loading. Change
`app/controllers/posts_controller.rb` and
`app/views/posts/index.html.erb`
```ruby
def index
@posts = Post.includes(:comments)
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @posts }
end
end
```
```
<% @posts.each do |post| %>
| <%= post.name %> |
<%= link_to 'Show', post %> |
<%= link_to 'Edit', edit_post_path(post) %> |
<%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %> |
<% end %>
```
12\. Refresh `http://localhost:3000/posts`, and you will see a popup alert box that says
```
The request has unused preload associations as follows:
model: Post => associations: [comment]
The request has N+1 queries as follows:
None
```
Meanwhile, there's a line appended to `log/bullet.log`
```
2009-08-25 21:13:22[INFO] Unused preload associations: PATH_INFO: /posts; model: Post => associations: [comments]·
Remove from your finder: :include => [:comments]
```
13\. Simulate counter_cache. Change `app/controllers/posts_controller.rb`
and `app/views/posts/index.html.erb`
```ruby
def index
@posts = Post.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @posts }
end
end
```
```
<% @posts.each do |post| %>
| <%= post.name %> |
<%= post.comments.size %> |
<%= link_to 'Show', post %> |
<%= link_to 'Edit', edit_post_path(post) %> |
<%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %> |
<% end %>
```
14\. Refresh `http://localhost:3000/posts`, then you will see a popup alert box that says
```
Need counter cache
Post => [:comments]
```
Meanwhile, there's a line appended to `log/bullet.log`
```
2009-09-11 10:07:10[INFO] Need Counter Cache
Post => [:comments]
```
Copyright (c) 2009 - 2019 Richard Huang (flyerhzm@gmail.com), released under the MIT license
bullet-6.1.0/Hacking.md 0000644 0001750 0001750 00000006510 13704275356 016131 0 ustar debbiecocoa debbiecocoa # Bullet Overview for Developers
This file aims to give developers a quick tour of the bullet internals, making
it (hopefully) easier to extend or enhance the Bullet gem.
## General Control Flow aka. 10000 Meter View
When Rails is initialized, Bullet will extend ActiveRecord (and if you're using
Rails 2.x ActiveController too) with the relevant modules and methods found
in lib/bullet/active_recordX.rb and lib/bullet/action_controller2.rb. If you're
running Rails 3, Bullet will integrate itself as a middleware into the Rack
stack, so ActionController does not need to be extended.
The ActiveRecord extensions will call methods in a given detector class, when
certain methods are called.
Detector classes contain all the logic to recognize
a noteworthy event. If such an event is detected, an instance of the
corresponding Notification class is created and stored in a Set instance in the
main Bullet module (the 'notification collector').
Notification instances contain the message that will be displayed, and will
use a Presenter class to display their message to the user.
So the flow of a request goes like this:
1. Bullet.start_request is called, which resets all the detectors and empties
the notification collector
2. The request is handled by Rails, and the installed ActiveRecord extensions
trigger Detector callbacks
3. Detectors once called, will determine whether something noteworthy happened.
If yes, then a Notification is created and stored in the notification collector.
4. Rails finishes handling the request
5. For each notification in the collector, Bullet will iterate over each
Presenter and will try to generate an inline message that will be appended to
the generated response body.
6. The response is returned to the client.
7. Bullet will try to generate an out-of-channel message for each notification.
8. Bullet calls end_request for each detector.
9. Goto 1.
## Adding Notification Types
If you want to add more kinds of things that Bullet can detect, a little more
work is needed than if you were just adding a Presenter, but the concepts are
similar.
* Add the class to the DETECTORS constant in the main Bullet module
* Add (if needed) Rails monkey patches to Bullet.enable
* Add an autoload directive to lib/bullet/detector.rb
* Create a corresponding notification class in the Bullet::Notification namespace
* Add an autoload directive to lib/bullet/notification.rb
As a rule of thumb, you can assume that each Detector will have its own
Notification class. If you follow the principle of Separation of Concerns I
can't really think of an example where one would deviate from this rule.
Since the detection of pathological associations is a bit hairy, I'd recommend
having a look at the counter cache detector and associated notification to get
a feel for what is needed to get off the ground.
### Detectors
The only things you'll need to consider when building your Detector class is
that it will need to supply the .start_request, .end_request and .clear class
methods.
Simple implementations are provided by Bullet::Detector::Base for start_request
and end_request, you will have to supply your own clear method.
### Notifications
For notifications you will want to supply a #title and #body instance method,
and check to see if the #initialize and #full_notice methods in the
Bullet::Notification::Base class fit your needs.
bullet-6.1.0/test.sh 0000755 0001750 0001750 00000002357 13704275356 015566 0 ustar debbiecocoa debbiecocoa #bundle update rails && bundle exec rspec spec
#BUNDLE_GEMFILE=Gemfile.mongoid bundle update mongoid && BUNDLE_GEMFILE=Gemfile.mongoid bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-6.0 bundle && BUNDLE_GEMFILE=Gemfile.rails-6.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-5.2 bundle && BUNDLE_GEMFILE=Gemfile.rails-5.2 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-5.1 bundle && BUNDLE_GEMFILE=Gemfile.rails-5.1 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-5.0 bundle && BUNDLE_GEMFILE=Gemfile.rails-5.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-4.2 bundle && BUNDLE_GEMFILE=Gemfile.rails-4.2 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-4.1 bundle && BUNDLE_GEMFILE=Gemfile.rails-4.1 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.rails-4.0 bundle && BUNDLE_GEMFILE=Gemfile.rails-4.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.mongoid-7.0 bundle && BUNDLE_GEMFILE=Gemfile.mongoid-7.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.mongoid-6.0 bundle && BUNDLE_GEMFILE=Gemfile.mongoid-6.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.mongoid-5.0 bundle && BUNDLE_GEMFILE=Gemfile.mongoid-5.0 bundle exec rspec spec
BUNDLE_GEMFILE=Gemfile.mongoid-4.0 bundle && BUNDLE_GEMFILE=Gemfile.mongoid-4.0 bundle exec rspec spec
bullet-6.1.0/.gitignore 0000644 0001750 0001750 00000000243 13704275356 016230 0 ustar debbiecocoa debbiecocoa log/**
pkg/**
.DS_Store
lib/.DS_Store
.*.swp
coverage.data
tags
.bundle
*.gem
benchmark_profile*
/nbproject/private/
coverage/
.coveralls.yml
Gemfile*.lock
.idea/
bullet-6.1.0/.rspec 0000644 0001750 0001750 00000000033 13704275356 015352 0 ustar debbiecocoa debbiecocoa --colour
--format progress
bullet-6.1.0/Gemfile.rails-6.0 0000644 0001750 0001750 00000000377 13704275356 017155 0 ustar debbiecocoa debbiecocoa source "https://rubygems.org"
gemspec
gem 'rails', '6.0.0'
gem 'sqlite3'
gem 'activerecord-jdbcsqlite3-adapter', platforms: [:jruby]
gem 'activerecord-import'
gem "rspec"
platforms :rbx do
gem 'rubysl', '~> 2.0'
gem 'rubinius-developer_tools'
end
bullet-6.1.0/rails/ 0000755 0001750 0001750 00000000000 13704275356 015353 5 ustar debbiecocoa debbiecocoa bullet-6.1.0/rails/init.rb 0000644 0001750 0001750 00000000060 13704275356 016637 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
require 'bullet'
bullet-6.1.0/bullet.gemspec 0000644 0001750 0001750 00000002107 13704275356 017075 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
lib = File.expand_path('lib', __dir__)
$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
require 'bullet/version'
Gem::Specification.new do |s|
s.name = 'bullet'
s.version = Bullet::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ['Richard Huang']
s.email = ['flyerhzm@gmail.com']
s.homepage = 'https://github.com/flyerhzm/bullet'
s.summary = 'help to kill N+1 queries and unused eager loading.'
s.description = 'help to kill N+1 queries and unused eager loading.'
s.metadata = {
'changelog_uri' => 'https://github.com/flyerhzm/bullet/blob/master/CHANGELOG.md',
'source_code_uri' => 'https://github.com/flyerhzm/bullet'
}
s.license = 'MIT'
s.required_ruby_version = '>= 2.3'
s.required_rubygems_version = '>= 1.3.6'
s.add_runtime_dependency 'activesupport', '>= 3.0.0'
s.add_runtime_dependency 'uniform_notifier', '~> 1.11'
s.files = `git ls-files`.split("\n")
s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
s.require_paths = ['lib']
end
bullet-6.1.0/perf/ 0000755 0001750 0001750 00000000000 13704275356 015175 5 ustar debbiecocoa debbiecocoa bullet-6.1.0/perf/benchmark.rb 0000644 0001750 0001750 00000006352 13704275356 017462 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
$LOAD_PATH << 'lib'
require 'benchmark'
require 'rails'
require 'active_record'
require 'activerecord-import'
require 'bullet'
begin
require 'perftools'
rescue LoadError
puts "Could not load perftools.rb, profiling won't be possible"
end
class Post < ActiveRecord::Base
belongs_to :user
has_many :comments
end
class Comment < ActiveRecord::Base
belongs_to :user
belongs_to :post
end
class User < ActiveRecord::Base
has_many :posts
has_many :comments
end
# create database bullet_benchmark;
ActiveRecord::Base.establish_connection(
adapter: 'mysql2', database: 'bullet_benchmark', server: '/tmp/mysql.socket', username: 'root'
)
ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
ActiveRecord::Schema.define(version: 1) do
create_table :posts do |t|
t.column :title, :string
t.column :body, :string
t.column :user_id, :integer
end
create_table :comments do |t|
t.column :body, :string
t.column :post_id, :integer
t.column :user_id, :integer
end
create_table :users do |t|
t.column :name, :string
end
end
users_size = 100
posts_size = 1_000
comments_size = 10_000
users = []
users_size.times { |i| users << User.new(name: "user#{i}") }
User.import users
users = User.all
posts = []
posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}", user: users[i % 100]) }
Post.import posts
posts = Post.all
comments = []
comments_size.times { |i| comments << Comment.new(body: "Comment #{i}", post: posts[i % 1_000], user: users[i % 100]) }
Comment.import comments
puts 'Start benchmarking...'
Bullet.enable = true
Benchmark.bm(70) do |bm|
bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
10.times do
Bullet.start_request
Post.select('SQL_NO_CACHE *').includes(:user, comments: :user).each do |p|
p.title
p.user.name
p.comments.each do |c|
c.body
c.user.name
end
end
Bullet.end_request
end
end
end
puts 'End benchmarking...'
# Run benchmark with bundler
#
# bundle exec ruby perf/benchmark.rb
#
# bullet 2.3.0 with rails 3.2.2
# user system total real
# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users 16.460000 0.190000 16.650000 ( 16.968246)
#
# bullet 2.3.0 with rails 3.1.4
# user system total real
# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users 14.600000 0.130000 14.730000 ( 14.937590)
#
# bullet 2.3.0 with rails 3.0.12
# user system total real
# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users 26.120000 0.430000 26.550000 ( 27.179304)
#
#
# bullet 2.2.1 with rails 3.0.12
# user system total real
# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users 29.970000 0.270000 30.240000 ( 30.452083)
bullet-6.1.0/Gemfile.mongoid 0000644 0001750 0001750 00000000351 13704275356 017166 0 ustar debbiecocoa debbiecocoa source "https://rubygems.org"
gemspec
gem 'rails'
gem 'sqlite3', platforms: [:ruby]
gem 'activerecord-jdbcsqlite3-adapter', platforms: [:jruby]
gem 'mongoid', github: 'mongoid/mongoid'
gem "rspec"
gem 'coveralls', require: false
bullet-6.1.0/.travis.yml 0000644 0001750 0001750 00000001324 13704275356 016352 0 ustar debbiecocoa debbiecocoa language: ruby
rvm:
- 2.3.0
- 2.6.0
gemfile:
- Gemfile.rails-6.0
- Gemfile.rails-5.2
- Gemfile.rails-5.1
- Gemfile.rails-5.0
- Gemfile.rails-4.2
- Gemfile.rails-4.1
- Gemfile.rails-4.0
matrix:
exclude:
- rvm: 2.3.0
gemfile: Gemfile.rails-6.0
- rvm: 2.6.0
gemfile: Gemfile.rails-5.2
- rvm: 2.6.0
gemfile: Gemfile.rails-5.1
- rvm: 2.6.0
gemfile: Gemfile.rails-5.0
- rvm: 2.6.0
gemfile: Gemfile.rails-4.2
- rvm: 2.6.0
gemfile: Gemfile.rails-4.1
- rvm: 2.6.0
gemfile: Gemfile.rails-4.0
env:
- DB=sqlite
before_install:
- "find /home/travis/.rvm/rubies -wholename '*default/bundler-*.gemspec' -delete"
- gem install bundler -v '< 2'
bullet-6.1.0/Gemfile.rails-5.2 0000644 0001750 0001750 00000000416 13704275356 017150 0 ustar debbiecocoa debbiecocoa source "https://rubygems.org"
gemspec
gem 'rails', '~> 5.2.0'
gem 'sqlite3', '~> 1.3.6'
gem 'activerecord-jdbcsqlite3-adapter', platforms: [:jruby]
gem 'activerecord-import'
gem "rspec"
platforms :rbx do
gem 'rubysl', '~> 2.0'
gem 'rubinius-developer_tools'
end
bullet-6.1.0/lib/ 0000755 0001750 0001750 00000000000 13704275356 015007 5 ustar debbiecocoa debbiecocoa bullet-6.1.0/lib/bullet.rb 0000644 0001750 0001750 00000017371 13704275356 016634 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
require 'active_support/core_ext/module/delegation'
require 'set'
require 'uniform_notifier'
require 'bullet/ext/object'
require 'bullet/ext/string'
require 'bullet/dependency'
require 'bullet/stack_trace_filter'
module Bullet
extend Dependency
autoload :ActiveRecord, "bullet/#{active_record_version}" if active_record?
autoload :Mongoid, "bullet/#{mongoid_version}" if mongoid?
autoload :Rack, 'bullet/rack'
autoload :ActiveJob, 'bullet/active_job'
autoload :Notification, 'bullet/notification'
autoload :Detector, 'bullet/detector'
autoload :Registry, 'bullet/registry'
autoload :NotificationCollector, 'bullet/notification_collector'
BULLET_DEBUG = 'BULLET_DEBUG'
TRUE = 'true'
if defined?(Rails::Railtie)
class BulletRailtie < Rails::Railtie
initializer 'bullet.configure_rails_initialization' do |app|
app.middleware.use Bullet::Rack
end
end
end
class << self
attr_writer :n_plus_one_query_enable,
:unused_eager_loading_enable,
:counter_cache_enable,
:stacktrace_includes,
:stacktrace_excludes,
:skip_html_injection
attr_reader :whitelist
attr_accessor :add_footer, :orm_patches_applied
available_notifiers = UniformNotifier::AVAILABLE_NOTIFIERS.map { |notifier| "#{notifier}=" }
available_notifiers_options = { to: UniformNotifier }
delegate(*available_notifiers, **available_notifiers_options)
def raise=(should_raise)
UniformNotifier.raise = (should_raise ? Notification::UnoptimizedQueryError : false)
end
DETECTORS = [
Bullet::Detector::NPlusOneQuery,
Bullet::Detector::UnusedEagerLoading,
Bullet::Detector::CounterCache
].freeze
def enable=(enable)
@enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
if enable?
reset_whitelist
unless orm_patches_applied
self.orm_patches_applied = true
Bullet::Mongoid.enable if mongoid?
Bullet::ActiveRecord.enable if active_record?
end
end
end
def enable?
!!@enable
end
def app_root
(defined?(::Rails.root) ? Rails.root.to_s : Dir.pwd).to_s
end
def n_plus_one_query_enable?
enable? && !!@n_plus_one_query_enable
end
def unused_eager_loading_enable?
enable? && !!@unused_eager_loading_enable
end
def counter_cache_enable?
enable? && !!@counter_cache_enable
end
def stacktrace_includes
@stacktrace_includes || []
end
def stacktrace_excludes
@stacktrace_excludes || []
end
def add_whitelist(options)
reset_whitelist
@whitelist[options[:type]][options[:class_name]] ||= []
@whitelist[options[:type]][options[:class_name]] << options[:association].to_sym
end
def delete_whitelist(options)
reset_whitelist
@whitelist[options[:type]][options[:class_name]] ||= []
@whitelist[options[:type]][options[:class_name]].delete(options[:association].to_sym)
@whitelist[options[:type]].delete_if { |_key, val| val.empty? }
end
def get_whitelist_associations(type, class_name)
Array(@whitelist[type][class_name])
end
def reset_whitelist
@whitelist ||= { n_plus_one_query: {}, unused_eager_loading: {}, counter_cache: {} }
end
def clear_whitelist
@whitelist = nil
end
def bullet_logger=(active)
if active
require 'fileutils'
FileUtils.mkdir_p(app_root + '/log')
bullet_log_file = File.open("#{app_root}/log/bullet.log", 'a+')
bullet_log_file.sync = true
UniformNotifier.customized_logger = bullet_log_file
end
end
def debug(title, message)
puts "[Bullet][#{title}] #{message}" if ENV[BULLET_DEBUG] == TRUE
end
def start_request
Thread.current[:bullet_start] = true
Thread.current[:bullet_notification_collector] = Bullet::NotificationCollector.new
Thread.current[:bullet_object_associations] = Bullet::Registry::Base.new
Thread.current[:bullet_call_object_associations] = Bullet::Registry::Base.new
Thread.current[:bullet_possible_objects] = Bullet::Registry::Object.new
Thread.current[:bullet_impossible_objects] = Bullet::Registry::Object.new
Thread.current[:bullet_inversed_objects] = Bullet::Registry::Base.new
Thread.current[:bullet_eager_loadings] = Bullet::Registry::Association.new
Thread.current[:bullet_counter_possible_objects] ||= Bullet::Registry::Object.new
Thread.current[:bullet_counter_impossible_objects] ||= Bullet::Registry::Object.new
end
def end_request
Thread.current[:bullet_start] = nil
Thread.current[:bullet_notification_collector] = nil
Thread.current[:bullet_object_associations] = nil
Thread.current[:bullet_call_object_associations] = nil
Thread.current[:bullet_possible_objects] = nil
Thread.current[:bullet_impossible_objects] = nil
Thread.current[:bullet_inversed_objects] = nil
Thread.current[:bullet_eager_loadings] = nil
Thread.current[:bullet_counter_possible_objects] = nil
Thread.current[:bullet_counter_impossible_objects] = nil
end
def start?
enable? && Thread.current[:bullet_start]
end
def notification_collector
Thread.current[:bullet_notification_collector]
end
def notification?
return unless start?
Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
notification_collector.notifications_present?
end
def gather_inline_notifications
responses = []
for_each_active_notifier_with_notification { |notification| responses << notification.notify_inline }
responses.join("\n")
end
def perform_out_of_channel_notifications(env = {})
request_uri = build_request_uri(env)
for_each_active_notifier_with_notification do |notification|
notification.url = request_uri
notification.notify_out_of_channel
end
end
def footer_info
info = []
notification_collector.collection.each { |notification| info << notification.short_notice }
info
end
def text_notifications
info = []
notification_collector.collection.each do |notification|
info << notification.notification_data.values.compact.join("\n")
end
info
end
def warnings
notification_collector.collection.each_with_object({}) do |notification, warnings|
warning_type = notification.class.to_s.split(':').last.tableize
warnings[warning_type] ||= []
warnings[warning_type] << notification
end
end
def profile
return_value = nil
if Bullet.enable?
begin
Bullet.start_request
return_value = yield
Bullet.perform_out_of_channel_notifications if Bullet.notification?
ensure
Bullet.end_request
end
else
return_value = yield
end
return_value
end
def console_enabled?
UniformNotifier.active_notifiers.include?(UniformNotifier::JavascriptConsole)
end
def skip_html_injection?
@skip_html_injection || false
end
private
def for_each_active_notifier_with_notification
UniformNotifier.active_notifiers.each do |notifier|
notification_collector.collection.each do |notification|
notification.notifier = notifier
yield notification
end
end
end
def build_request_uri(env)
return "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']}" if env['REQUEST_URI']
if env['QUERY_STRING'].present?
"#{env['REQUEST_METHOD']} #{env['PATH_INFO']}?#{env['QUERY_STRING']}"
else
"#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
end
end
end
end
bullet-6.1.0/lib/bullet/ 0000755 0001750 0001750 00000000000 13704275356 016276 5 ustar debbiecocoa debbiecocoa bullet-6.1.0/lib/bullet/active_record60.rb 0000644 0001750 0001750 00000023303 13704275356 021603 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module SaveWithBulletSupport
def _create_record(*)
super do
Bullet::Detector::NPlusOneQuery.add_impossible_object(self)
yield(self) if block_given?
end
end
end
module ActiveRecord
def self.enable
require 'active_record'
::ActiveRecord::Base.extend(
Module.new do
def find_by_sql(sql, binds = [], preparable: nil, &block)
result = super
if Bullet.start?
if result.is_a? Array
if result.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
Bullet::Detector::CounterCache.add_possible_objects(result)
elsif result.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
Bullet::Detector::CounterCache.add_impossible_object(result.first)
end
elsif result.is_a? ::ActiveRecord::Base
Bullet::Detector::NPlusOneQuery.add_impossible_object(result)
Bullet::Detector::CounterCache.add_impossible_object(result)
end
end
result
end
end
)
::ActiveRecord::Base.prepend(SaveWithBulletSupport)
::ActiveRecord::Relation.prepend(
Module.new do
# if select a collection of objects, then these objects have possible to cause N+1 query.
# if select only one object, then the only one object has impossible to cause N+1 query.
def records
result = super
if Bullet.start?
if result.first.class.name !~ /^HABTM_/
if result.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
Bullet::Detector::CounterCache.add_possible_objects(result)
elsif result.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
Bullet::Detector::CounterCache.add_impossible_object(result.first)
end
end
end
result
end
end
)
::ActiveRecord::Associations::Preloader.prepend(
Module.new do
def preloaders_for_one(association, records, scope, polymorphic_parent)
if Bullet.start?
records.compact!
if records.first.class.name !~ /^HABTM_/
records.each { |record| Bullet::Detector::Association.add_object_associations(record, association) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, association)
end
end
super
end
def preloaders_for_reflection(reflection, records, scope)
if Bullet.start?
records.compact!
if records.first.class.name !~ /^HABTM_/
records.each { |record| Bullet::Detector::Association.add_object_associations(record, reflection.name) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, reflection.name)
end
end
super
end
end
)
::ActiveRecord::Associations::Preloader::ThroughAssociation.prepend(
Module.new do
def preloaded_records
if Bullet.start? && !defined?(@preloaded_records)
source_preloaders.each do |source_preloader|
reflection_name = source_preloader.send(:reflection).name
source_preloader.send(:owners).each do |owner|
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection_name)
end
end
end
super
end
end
)
::ActiveRecord::FinderMethods.prepend(
Module.new do
# add includes in scope
def find_with_associations
return super { |r| yield r } if block_given?
records = super
if Bullet.start?
associations = (eager_load_values + includes_values).uniq
records.each { |record| Bullet::Detector::Association.add_object_associations(record, associations) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
end
records
end
end
)
::ActiveRecord::Associations::JoinDependency.prepend(
Module.new do
def instantiate(result_set, &block)
@bullet_eager_loadings = {}
records = super
if Bullet.start?
@bullet_eager_loadings.each do |_klazz, eager_loadings_hash|
objects = eager_loadings_hash.keys
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(
objects,
eager_loadings_hash[objects.first].to_a
)
end
end
records
end
def construct(ar_parent, parent, row, seen, model_cache)
if Bullet.start?
unless ar_parent.nil?
parent.children.each do |node|
key = aliases.column_alias(node, node.primary_key)
id = row[key]
next unless id.nil?
associations = node.reflection.name
Bullet::Detector::Association.add_object_associations(ar_parent, associations)
Bullet::Detector::NPlusOneQuery.call_association(ar_parent, associations)
@bullet_eager_loadings[ar_parent.class] ||= {}
@bullet_eager_loadings[ar_parent.class][ar_parent] ||= Set.new
@bullet_eager_loadings[ar_parent.class][ar_parent] << associations
end
end
end
super
end
# call join associations
def construct_model(record, node, row, model_cache, id)
result = super
if Bullet.start?
associations = node.reflection.name
Bullet::Detector::Association.add_object_associations(record, associations)
Bullet::Detector::NPlusOneQuery.call_association(record, associations)
@bullet_eager_loadings[record.class] ||= {}
@bullet_eager_loadings[record.class][record] ||= Set.new
@bullet_eager_loadings[record.class][record] << associations
end
result
end
end
)
::ActiveRecord::Associations::CollectionAssociation.prepend(
Module.new do
def load_target
records = super
if Bullet.start?
if is_a? ::ActiveRecord::Associations::ThroughAssociation
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
association = owner.association(reflection.through_reflection.name)
Array(association.target).each do |through_record|
Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
end
if reflection.through_reflection != through_reflection
Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
end
end
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) unless @inversed
if records.first.class.name !~ /^HABTM_/
if records.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
Bullet::Detector::CounterCache.add_possible_objects(records)
elsif records.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
Bullet::Detector::CounterCache.add_impossible_object(records.first)
end
end
end
records
end
def empty?
if Bullet.start? && !reflection.has_cached_counter?
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
end
super
end
def include?(object)
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) if Bullet.start?
super
end
end
)
::ActiveRecord::Associations::SingularAssociation.prepend(
Module.new do
# call has_one and belongs_to associations
def target
result = super()
if Bullet.start?
if owner.class.name !~ /^HABTM_/ && !@inversed
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
if Bullet::Detector::NPlusOneQuery.impossible?(owner)
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
else
Bullet::Detector::NPlusOneQuery.add_possible_objects(result) if result
end
end
end
result
end
end
)
::ActiveRecord::Associations::HasManyAssociation.prepend(
Module.new do
def empty?
result = super
if Bullet.start? && !reflection.has_cached_counter?
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
end
result
end
def count_records
result = reflection.has_cached_counter?
if Bullet.start? && !result && !is_a?(::ActiveRecord::Associations::ThroughAssociation)
Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name)
end
super
end
end
)
end
end
end
bullet-6.1.0/lib/bullet/mongoid7x.rb 0000644 0001750 0001750 00000003505 13704275356 020541 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module Mongoid
def self.enable
require 'mongoid'
::Mongoid::Contextual::Mongo.class_eval do
alias_method :origin_first, :first
alias_method :origin_last, :last
alias_method :origin_each, :each
alias_method :origin_eager_load, :eager_load
def first(opts = {})
result = origin_first(opts)
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
result
end
def last(opts = {})
result = origin_last(opts)
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
result
end
def each(&block)
return to_enum unless block_given?
records = []
origin_each { |record| records << record }
if records.length > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
elsif records.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
end
records.each(&block)
end
def eager_load(docs)
associations = criteria.inclusions.map(&:name)
docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
origin_eager_load(docs)
end
end
::Mongoid::Association::Accessors.class_eval do
alias_method :origin_get_relation, :get_relation
def get_relation(name, association, object, reload = false)
result = origin_get_relation(name, association, object, reload)
Bullet::Detector::NPlusOneQuery.call_association(self, name) unless association.embedded?
result
end
end
end
end
end
bullet-6.1.0/lib/bullet/registry.rb 0000644 0001750 0001750 00000000334 13704275356 020473 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module Registry
autoload :Base, 'bullet/registry/base'
autoload :Object, 'bullet/registry/object'
autoload :Association, 'bullet/registry/association'
end
end
bullet-6.1.0/lib/bullet/active_record52.rb 0000644 0001750 0001750 00000021246 13704275356 021610 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module SaveWithBulletSupport
def _create_record(*)
super do
Bullet::Detector::NPlusOneQuery.add_impossible_object(self)
yield(self) if block_given?
end
end
end
module ActiveRecord
def self.enable
require 'active_record'
::ActiveRecord::Base.extend(
Module.new do
def find_by_sql(sql, binds = [], preparable: nil, &block)
result = super
if Bullet.start?
if result.is_a? Array
if result.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
Bullet::Detector::CounterCache.add_possible_objects(result)
elsif result.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
Bullet::Detector::CounterCache.add_impossible_object(result.first)
end
elsif result.is_a? ::ActiveRecord::Base
Bullet::Detector::NPlusOneQuery.add_impossible_object(result)
Bullet::Detector::CounterCache.add_impossible_object(result)
end
end
result
end
end
)
::ActiveRecord::Base.prepend(SaveWithBulletSupport)
::ActiveRecord::Relation.prepend(
Module.new do
# if select a collection of objects, then these objects have possible to cause N+1 query.
# if select only one object, then the only one object has impossible to cause N+1 query.
def records
result = super
if Bullet.start?
if result.first.class.name !~ /^HABTM_/
if result.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
Bullet::Detector::CounterCache.add_possible_objects(result)
elsif result.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
Bullet::Detector::CounterCache.add_impossible_object(result.first)
end
end
end
result
end
end
)
::ActiveRecord::Associations::Preloader.prepend(
Module.new do
def preloaders_for_one(association, records, scope)
if Bullet.start?
records.compact!
if records.first.class.name !~ /^HABTM_/
records.each { |record| Bullet::Detector::Association.add_object_associations(record, association) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, association)
end
end
super
end
end
)
::ActiveRecord::FinderMethods.prepend(
Module.new do
# add includes in scope
def find_with_associations
return super { |r| yield r } if block_given?
records = super
if Bullet.start?
associations = (eager_load_values + includes_values).uniq
records.each { |record| Bullet::Detector::Association.add_object_associations(record, associations) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
end
records
end
end
)
::ActiveRecord::Associations::JoinDependency.prepend(
Module.new do
def instantiate(result_set, &block)
@bullet_eager_loadings = {}
records = super
if Bullet.start?
@bullet_eager_loadings.each do |_klazz, eager_loadings_hash|
objects = eager_loadings_hash.keys
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(
objects,
eager_loadings_hash[objects.first].to_a
)
end
end
records
end
def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
if Bullet.start?
unless ar_parent.nil?
parent.children.each do |node|
key = aliases.column_alias(node, node.primary_key)
id = row[key]
next unless id.nil?
associations = node.reflection.name
Bullet::Detector::Association.add_object_associations(ar_parent, associations)
Bullet::Detector::NPlusOneQuery.call_association(ar_parent, associations)
@bullet_eager_loadings[ar_parent.class] ||= {}
@bullet_eager_loadings[ar_parent.class][ar_parent] ||= Set.new
@bullet_eager_loadings[ar_parent.class][ar_parent] << associations
end
end
end
super
end
# call join associations
def construct_model(record, node, row, model_cache, id, aliases)
result = super
if Bullet.start?
associations = node.reflection.name
Bullet::Detector::Association.add_object_associations(record, associations)
Bullet::Detector::NPlusOneQuery.call_association(record, associations)
@bullet_eager_loadings[record.class] ||= {}
@bullet_eager_loadings[record.class][record] ||= Set.new
@bullet_eager_loadings[record.class][record] << associations
end
result
end
end
)
::ActiveRecord::Associations::CollectionAssociation.prepend(
Module.new do
def load_target
records = super
if Bullet.start?
if is_a? ::ActiveRecord::Associations::ThroughAssociation
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.through_reflection.name)
association = owner.association reflection.through_reflection.name
Array(association.target).each do |through_record|
Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
end
if reflection.through_reflection != through_reflection
Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
end
end
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) unless @inversed
if records.first.class.name !~ /^HABTM_/
if records.size > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
Bullet::Detector::CounterCache.add_possible_objects(records)
elsif records.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
Bullet::Detector::CounterCache.add_impossible_object(records.first)
end
end
end
records
end
def empty?
if Bullet.start? && !reflection.has_cached_counter?
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
end
super
end
def include?(object)
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) if Bullet.start?
super
end
end
)
::ActiveRecord::Associations::SingularAssociation.prepend(
Module.new do
# call has_one and belongs_to associations
def target
result = super()
if Bullet.start?
if owner.class.name !~ /^HABTM_/ && !@inversed
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
if Bullet::Detector::NPlusOneQuery.impossible?(owner)
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
else
Bullet::Detector::NPlusOneQuery.add_possible_objects(result) if result
end
end
end
result
end
end
)
::ActiveRecord::Associations::HasManyAssociation.prepend(
Module.new do
def empty?
result = super
if Bullet.start? && !reflection.has_cached_counter?
Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
end
result
end
def count_records
result = reflection.has_cached_counter?
if Bullet.start? && !result && !is_a?(::ActiveRecord::Associations::ThroughAssociation)
Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name)
end
super
end
end
)
end
end
end
bullet-6.1.0/lib/bullet/stack_trace_filter.rb 0000644 0001750 0001750 00000003426 13704275356 022460 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module StackTraceFilter
VENDOR_PATH = '/vendor'
def caller_in_project
vendor_root = Bullet.app_root + VENDOR_PATH
bundler_path = Bundler.bundle_path.to_s
select_caller_locations do |location|
caller_path = location_as_path(location)
caller_path.include?(Bullet.app_root) && !caller_path.include?(vendor_root) &&
!caller_path.include?(bundler_path) ||
Bullet.stacktrace_includes.any? { |include_pattern| pattern_matches?(location, include_pattern) }
end
end
def excluded_stacktrace_path?
Bullet.stacktrace_excludes.any? do |exclude_pattern|
caller_in_project.any? { |location| pattern_matches?(location, exclude_pattern) }
end
end
private
def pattern_matches?(location, pattern)
path = location_as_path(location)
case pattern
when Array
pattern_path = pattern.first
filter = pattern.last
return false unless pattern_matches?(location, pattern_path)
case filter
when Range
filter.include?(location.lineno)
when Integer
filter == location.lineno
when String
filter == location.base_label
end
when String
path.include?(pattern)
when Regexp
path =~ pattern
end
end
def location_as_path(location)
ruby_19? ? location : location.absolute_path.to_s
end
def select_caller_locations
if ruby_19?
caller.select { |caller_path| yield caller_path }
else
caller_locations.select { |location| yield location }
end
end
def ruby_19?
@ruby_19 = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0') if @ruby_19.nil?
@ruby_19
end
end
end
bullet-6.1.0/lib/bullet/dependency.rb 0000644 0001750 0001750 00000004722 13704275356 020746 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module Dependency
def mongoid?
@mongoid ||= defined?(::Mongoid)
end
def active_record?
@active_record ||= defined?(::ActiveRecord)
end
def active_record_version
@active_record_version ||=
begin
if active_record40?
'active_record4'
elsif active_record41?
'active_record41'
elsif active_record42?
'active_record42'
elsif active_record50?
'active_record5'
elsif active_record51?
'active_record5'
elsif active_record52?
'active_record52'
elsif active_record60?
'active_record60'
else
raise "Bullet does not support active_record #{::ActiveRecord::VERSION::STRING} yet"
end
end
end
def mongoid_version
@mongoid_version ||=
begin
if mongoid4x?
'mongoid4x'
elsif mongoid5x?
'mongoid5x'
elsif mongoid6x?
'mongoid6x'
elsif mongoid7x?
'mongoid7x'
else
raise "Bullet does not support mongoid #{::Mongoid::VERSION} yet"
end
end
end
def active_record4?
active_record? && ::ActiveRecord::VERSION::MAJOR == 4
end
def active_record5?
active_record? && ::ActiveRecord::VERSION::MAJOR == 5
end
def active_record6?
active_record? && ::ActiveRecord::VERSION::MAJOR == 6
end
def active_record40?
active_record4? && ::ActiveRecord::VERSION::MINOR == 0
end
def active_record41?
active_record4? && ::ActiveRecord::VERSION::MINOR == 1
end
def active_record42?
active_record4? && ::ActiveRecord::VERSION::MINOR == 2
end
def active_record50?
active_record5? && ::ActiveRecord::VERSION::MINOR == 0
end
def active_record51?
active_record5? && ::ActiveRecord::VERSION::MINOR == 1
end
def active_record52?
active_record5? && ::ActiveRecord::VERSION::MINOR == 2
end
def active_record60?
active_record6? && ::ActiveRecord::VERSION::MINOR == 0
end
def mongoid4x?
mongoid? && ::Mongoid::VERSION =~ /\A4/
end
def mongoid5x?
mongoid? && ::Mongoid::VERSION =~ /\A5/
end
def mongoid6x?
mongoid? && ::Mongoid::VERSION =~ /\A6/
end
def mongoid7x?
mongoid? && ::Mongoid::VERSION =~ /\A7/
end
end
end
bullet-6.1.0/lib/bullet/mongoid5x.rb 0000644 0001750 0001750 00000003433 13704275356 020537 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
module Mongoid
def self.enable
require 'mongoid'
::Mongoid::Contextual::Mongo.class_eval do
alias_method :origin_first, :first
alias_method :origin_last, :last
alias_method :origin_each, :each
alias_method :origin_eager_load, :eager_load
def first
result = origin_first
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
result
end
def last
result = origin_last
Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
result
end
def each(&block)
return to_enum unless block_given?
records = []
origin_each { |record| records << record }
if records.length > 1
Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
elsif records.size == 1
Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
end
records.each(&block)
end
def eager_load(docs)
associations = criteria.inclusions.map(&:name)
docs.each { |doc| Bullet::Detector::NPlusOneQuery.add_object_associations(doc, associations) }
Bullet::Detector::UnusedEagerLoading.add_eager_loadings(docs, associations)
origin_eager_load(docs)
end
end
::Mongoid::Relations::Accessors.class_eval do
alias_method :origin_get_relation, :get_relation
def get_relation(name, metadata, object, reload = false)
result = origin_get_relation(name, metadata, object, reload)
Bullet::Detector::NPlusOneQuery.call_association(self, name) if metadata.macro !~ /embed/
result
end
end
end
end
end
bullet-6.1.0/lib/bullet/notification_collector.rb 0000644 0001750 0001750 00000000524 13704275356 023360 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
require 'set'
module Bullet
class NotificationCollector
attr_reader :collection
def initialize
reset
end
def reset
@collection = Set.new
end
def add(value)
@collection << value
end
def notifications_present?
!@collection.empty?
end
end
end
bullet-6.1.0/lib/bullet/rack.rb 0000644 0001750 0001750 00000010076 13704275356 017547 0 ustar debbiecocoa debbiecocoa # frozen_string_literal: true
module Bullet
class Rack
include Dependency
def initialize(app)
@app = app
end
def call(env)
return @app.call(env) unless Bullet.enable?
Bullet.start_request
status, headers, response = @app.call(env)
response_body = nil
if Bullet.notification?
if !Bullet.skip_html_injection? && !file?(headers) && !sse?(headers) && !empty?(response) && status == 200
if html_request?(headers, response)
response_body = response_body(response)
response_body = append_to_html_body(response_body, footer_note) if Bullet.add_footer
response_body = append_to_html_body(response_body, Bullet.gather_inline_notifications)
response_body = append_to_html_body(response_body, xhr_script)
headers['Content-Length'] = response_body.bytesize.to_s
else
set_header(headers, 'X-bullet-footer-text', Bullet.footer_info.uniq) if Bullet.add_footer
set_header(headers, 'X-bullet-console-text', Bullet.text_notifications) if Bullet.console_enabled?
end
end
Bullet.perform_out_of_channel_notifications(env)
end
[status, headers, response_body ? [response_body] : response]
ensure
Bullet.end_request
end
# fix issue if response's body is a Proc
def empty?(response)
# response may be ["Not Found"], ["Move Permanently"], etc, but
# those should not happen if the status is 200
body = response_body(response)
body.nil? || body.empty?
end
def append_to_html_body(response_body, content)
body = response_body.dup
if body.include?(' ')
position = body.rindex('')
body.insert(position, content)
else
body << content
end
end
def footer_note
"