active-record-transactioner 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ff5f7c2e010ea51c857be4b595aff6a11fc6a29
-  data.tar.gz: c1b7216f9189778553b7455faf98d33760658683
+  metadata.gz: d0d85c7182312c5329e6c8731c57aa2d737f9952
+  data.tar.gz: 42316fbb652cfef2b9b35b0c572244dde822b404
 SHA512:
-  metadata.gz: 8a4511fa3b9124dd3173097b6601c23af067afc4ac1964a251e3e80045aa282b0bd8431159d4385211dd979c12b5b2691166e36a169f4e4208fb68cb66a2015d
-  data.tar.gz: a2e7df57feb26de445f1bb4a416d67265ce16aac5cbb23a2ca9528d768fc10251f67d8dd261e90dfad5cd7be21653ff9af2a225ada422209277f93db0b02fa22
+  metadata.gz: 90e200215749d32941aace7319d6c05d0cd305bf237afa40740d441078542fc83a6e647385449e2e4b9908f389471c59b27c90e4034b0d9612157816452b81ce
+  data.tar.gz: 2ee07d9fa63ebb9bb7ec9f4d620eef2ea98166fe25464497c42ecfebb533cdbb3e392fcd0bcdd4eeb4eb586452bf707797f86b4ad5b9059392ec9943d832da21

data/Gemfile

@@ -6,9 +6,15 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", "~> 2.8.0"
+  gem "rails", "~> 4.0.10"
+  gem "rspec-rails", "~> 3.1.0"
   gem "rdoc", "~> 3.12"
   gem "bundler", ">= 1.0.0"
   gem "jeweler", ">= 1.8.4"
   gem "builder"
+  gem "activerecord"
+  gem "mysql2"
+  gem "pry"
 end
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/Gemfile.lock

@@ -1,11 +1,41 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    actionmailer (4.0.12)
+      actionpack (= 4.0.12)
+      mail (~> 2.5, >= 2.5.4)
+    actionpack (4.0.12)
+      activesupport (= 4.0.12)
+      builder (~> 3.1.0)
+      erubis (~> 2.7.0)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    activemodel (4.0.12)
+      activesupport (= 4.0.12)
+      builder (~> 3.1.0)
+    activerecord (4.0.12)
+      activemodel (= 4.0.12)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.12)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.12)
+      i18n (~> 0.6, >= 0.6.9)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
     addressable (2.3.6)
-    builder (3.2.2)
+    arel (4.0.2)
+    builder (3.1.4)
+    codeclimate-test-reporter (0.4.2)
+      simplecov (>= 0.7.1, < 1.0.0)
+    coderay (1.1.0)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
-    diff-lcs (1.1.3)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    erubis (2.7.0)
     faraday (0.9.0)
       multipart-post (>= 1.2, < 3)
     git (1.2.6)
@@ -19,6 +49,8 @@ GEM
       oauth2
     hashie (2.1.1)
     highline (1.6.21)
+    hike (1.2.3)
+    i18n (0.6.11)
     jeweler (2.0.1)
       builder
       bundler (>= 1.0)
@@ -31,10 +63,16 @@ GEM
     json (1.8.1)
     jwt (0.1.13)
       multi_json (>= 1.5)
+    mail (2.6.3)
+      mime-types (>= 1.16, < 3)
+    method_source (0.8.2)
+    mime-types (2.4.3)
     mini_portile (0.6.0)
+    minitest (4.7.5)
     multi_json (1.10.0)
     multi_xml (0.5.5)
     multipart-post (2.0.0)
+    mysql2 (0.3.16)
     nokogiri (1.6.2.1)
       mini_portile (= 0.6.0)
     oauth2 (0.9.3)
@@ -43,26 +81,76 @@ GEM
       multi_json (~> 1.3)
       multi_xml (~> 0.5)
       rack (~> 1.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
     rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.0.12)
+      actionmailer (= 4.0.12)
+      actionpack (= 4.0.12)
+      activerecord (= 4.0.12)
+      activesupport (= 4.0.12)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.0.12)
+      sprockets-rails (~> 2.0)
+    railties (4.0.12)
+      actionpack (= 4.0.12)
+      activesupport (= 4.0.12)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
     rake (10.3.2)
     rdoc (3.12.2)
       json (~> 1.4)
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
-    thread_safe (0.3.3)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-rails (3.1.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    sprockets (2.12.3)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.2.2)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    tzinfo (0.3.42)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord
   builder
   bundler (>= 1.0.0)
+  codeclimate-test-reporter
   jeweler (>= 1.8.4)
+  mysql2
+  pry
+  rails (~> 4.0.10)
   rdoc (~> 3.12)
-  rspec (~> 2.8.0)
+  rspec-rails (~> 3.1.0)

data/README.md

@@ -0,0 +1,86 @@
+[![Build Status](https://api.shippable.com/projects/540e7b993479c5ea8f9ec1f2/badge?branchName=master)](https://app.shippable.com/projects/540e7b993479c5ea8f9ec1f2/builds/latest)
+[![Code Climate](https://codeclimate.com/github/kaspernj/active-record-transactioner/badges/gpa.svg)](https://codeclimate.com/github/kaspernj/active-record-transactioner)
+[![Test Coverage](https://codeclimate.com/github/kaspernj/active-record-transactioner/badges/coverage.svg)](https://codeclimate.com/github/kaspernj/active-record-transactioner)
+
+# active-record-transactioner
+
+Queue saving and destroying of many models into transactions through multiple threads for optimal database-performance in ActiveRecord.
+
+## Install
+
+Add to your Gemfile and bundle:
+```ruby
+gem 'active-record-transactioner'
+```
+
+## Usage
+
+### Iterate a million times - will update each 1000 records in a single transaction with `save!`.
+```ruby
+ActiveRecordTransactioner.new do |trans|
+  models.each do |model|
+    model.some_attribute = "some_value"
+    trans.save!(model)
+  end
+end
+```
+
+You can also do it a bit more complicated with some custom options.
+```ruby
+ActiveRecordTransactioner.new(
+  call_args: ["Hello world!"],
+  call_method: :save!,
+  transaction_method: :transaction,
+  transaction_size: 1000,
+  threadded: false
+) do |trans|
+  models.each do |model|
+    model.some_attribute = "some_value"
+    trans.save!(model)
+  end
+end
+```
+
+### Destroy
+```ruby
+ActiveRecordTransactioner.new do |trans|
+  models.each do |model|
+    trans.destroy!(model)
+  end
+end
+```
+
+### Threadded
+
+The "threadded" and "max_running_threads" options will start new threads to actually do the saving of the models, while continuing to queue up new models for saving in the primary thread. This way the database can utilize multiple cores, and if you use a threadded VM like JRuby or Rubinius, you will utilize even more cores.
+
+This can help greatly speed up the processing.
+
+Be aware that the saving of only one type of model, will be limited to only one thread, so it will make sense to try and queue up as many type of models as possible. Like users, orders and so on.
+
+```ruby
+ActiveRecordTransactioner.new(
+  threadded: true,
+  max_running_threads: 3
+) do |trans|
+  models.each do |model|
+    model.some_attribute = "some_value"
+    trans.save!(model)
+  end
+end
+```
+
+## Contributing to active-record-transactioner
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2013 Kasper Johansen. See LICENSE.txt for
+further details.

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/active-record-transactioner.gemspec

@@ -2,19 +2,21 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: active-record-transactioner 0.0.6 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "active-record-transactioner"
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Kasper Johansen"]
-  s.date = "2014-05-18"
+  s.date = "2014-12-05"
   s.description = "Queue up calls to specific models and execute them in transactions, after a certain number of models have been added."
   s.email = "kj@gfish.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
@@ -22,43 +24,100 @@ Gem::Specification.new do |s|
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "active-record-transactioner.gemspec",
     "lib/active-record-transactioner.rb",
+    "shippable.yml",
     "spec/active-record-transactioner_spec.rb",
+    "spec/dummy/README.rdoc",
+    "spec/dummy/Rakefile",
+    "spec/dummy/app/assets/images/.keep",
+    "spec/dummy/app/assets/javascripts/application.js",
+    "spec/dummy/app/assets/stylesheets/application.css",
+    "spec/dummy/app/controllers/application_controller.rb",
+    "spec/dummy/app/controllers/concerns/.keep",
+    "spec/dummy/app/helpers/application_helper.rb",
+    "spec/dummy/app/mailers/.keep",
+    "spec/dummy/app/models/concerns/.keep",
+    "spec/dummy/app/models/user.rb",
+    "spec/dummy/app/views/layouts/application.html.erb",
+    "spec/dummy/bin/bundle",
+    "spec/dummy/bin/rails",
+    "spec/dummy/bin/rake",
+    "spec/dummy/config.ru",
+    "spec/dummy/config/application.rb",
+    "spec/dummy/config/boot.rb",
+    "spec/dummy/config/database.example.yml",
+    "spec/dummy/config/database.shippable.yml",
+    "spec/dummy/config/database.yml",
+    "spec/dummy/config/environment.rb",
+    "spec/dummy/config/environments/development.rb",
+    "spec/dummy/config/environments/production.rb",
+    "spec/dummy/config/environments/test.rb",
+    "spec/dummy/config/initializers/backtrace_silencers.rb",
+    "spec/dummy/config/initializers/filter_parameter_logging.rb",
+    "spec/dummy/config/initializers/inflections.rb",
+    "spec/dummy/config/initializers/mime_types.rb",
+    "spec/dummy/config/initializers/secret_token.rb",
+    "spec/dummy/config/initializers/session_store.rb",
+    "spec/dummy/config/initializers/wrap_parameters.rb",
+    "spec/dummy/config/locales/en.yml",
+    "spec/dummy/config/routes.rb",
+    "spec/dummy/db/migrate/20141203180942_create_users.rb",
+    "spec/dummy/db/schema.rb",
+    "spec/dummy/lib/assets/.keep",
+    "spec/dummy/log/.keep",
+    "spec/dummy/public/404.html",
+    "spec/dummy/public/422.html",
+    "spec/dummy/public/500.html",
+    "spec/dummy/public/favicon.ico",
+    "spec/models/user_spec.rb",
+    "spec/models/user_threadded_spec.rb",
     "spec/spec_helper.rb",
+    "spec/support/basic_user_operations.rb",
     "spec/test_classes/active-record-transactioner-test-class.rb"
   ]
   s.homepage = "http://github.com/kaspernj/active-record-transactioner"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "2.0.7"
+  s.rubygems_version = "2.4.0"
   s.summary = "Queue up calls to specific models and execute them in transactions, after a certain number of models have been added."
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rails>, ["~> 4.0.10"])
+      s.add_development_dependency(%q<rspec-rails>, ["~> 3.1.0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
       s.add_development_dependency(%q<jeweler>, [">= 1.8.4"])
       s.add_development_dependency(%q<builder>, [">= 0"])
+      s.add_development_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<mysql2>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
     else
-      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rails>, ["~> 4.0.10"])
+      s.add_dependency(%q<rspec-rails>, ["~> 3.1.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_dependency(%q<bundler>, [">= 1.0.0"])
       s.add_dependency(%q<jeweler>, [">= 1.8.4"])
       s.add_dependency(%q<builder>, [">= 0"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rails>, ["~> 4.0.10"])
+    s.add_dependency(%q<rspec-rails>, ["~> 3.1.0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])
     s.add_dependency(%q<bundler>, [">= 1.0.0"])
     s.add_dependency(%q<jeweler>, [">= 1.8.4"])
     s.add_dependency(%q<builder>, [">= 0"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
   end
 end
 

data/lib/active-record-transactioner.rb

@@ -2,147 +2,184 @@ require "monitor"
 
 class ActiveRecordTransactioner
   DEFAULT_ARGS = {
-    :call_args => [],
-    :call_method => :save!,
-    :transaction_method => :transaction,
-    :transaction_size => 1000,
-    :max_running_threads => 2,
-    :debug => false
+    call_args: [],
+    call_method: :save!,
+    transaction_method: :transaction,
+    transaction_size: 1000,
+    threadded: false,
+    max_running_threads: 2,
+    debug: false
   }
-  
+
   ALLOWED_ARGS = DEFAULT_ARGS.keys
-  
+
   def initialize(args = {})
-    args.each do |key, val|
-      raise "Invalid key: '#{key}'." unless ALLOWED_ARGS.include?(key)
-    end
-    
+    args.each { |key, val| raise "Invalid key: '#{key}'." unless ALLOWED_ARGS.include?(key) }
+
     @args = DEFAULT_ARGS.merge(args)
-    @models = {}
-    @threads = []
-    @count = 0
-    @lock = Monitor.new
-    @lock_threads = Monitor.new
-    @lock_models = {}
-    @debug = @args[:debug]
-    
+    parse_and_set_args
+
     if block_given?
       begin
         yield self
       ensure
         flush
-        join
+        join if threadded?
       end
     end
   end
-  
-  #Adds another model to the queue and calls 'flush' if it is over the limit.
-  def queue(model)
+
+  # Adds another model to the queue and calls 'flush' if it is over the limit.
+  def save!(model)
+    raise ActiveRecord::RecordInvalid, model unless model.valid?
+    queue(model, type: :save!, validate: false)
+  end
+
+  def destroy!(model)
+    queue(model, type: :destroy!)
+  end
+
+  # Adds another model to the queue and calls 'flush' if it is over the limit.
+  def queue(model, args = {})
+    args[:type] ||= :save!
+
     @lock.synchronize do
       klass = model.class
-      
-      @lock_models[klass] = Mutex.new if !@lock_models.key?(klass)
-      @models[klass] = [] if !@models.key?(klass)
-      @models[klass] << model
+
+      validate = args.key?(:validate) ? args[:validate] : true
+
+      @lock_models[klass] ||= Monitor.new
+      @models[klass] ||= []
+      @models[klass] << {model: model, type: args[:type], validate: validate}
       @count += 1
     end
-    
-    flush if @count >= @args[:transaction_size]
+
+    flush if should_flush?
   end
-  
-  #Flushes the specified method on all the queued models in a thread for each type of model.
+
+  # Flushes the specified method on all the queued models in a thread for each type of model.
   def flush
-    threads = []
-    wait_for_threads
-    
+    wait_for_threads if threadded?
+
     @lock.synchronize do
-      @models.each do |klass, val|
-        next if val.empty?
-        
-        models = val
+      @models.each do |klass, models|
+        next if models.empty?
+
         @models[klass] = []
         @count -= models.length
-        thread = nil
-        
-        @lock_models[klass].synchronize do
-          thread = Thread.new do
-            begin
-              @lock_models[klass].synchronize do
-                debug "Opening new transaction by using '#{@args[:transaction_method]}'."
-                klass.__send__(@args[:transaction_method]) do
-                  models.each do |model|
-                    # debug "Saving #{model.class.name}(#{model.id}) with method #{@args[:call_method]}"
-                    model.__send__(@args[:call_method], *@args[:call_args])
-                  end
-                end
-              end
-            rescue => e
-              puts e.inspect
-              puts e.backtrace
-              
-              if e.is_a?(NoMethodError) and e.message.to_s.include?("`reverse' for nil:NilClass")
-                puts "Warning: Known Rails reverse error when using transaction - retrying in 2 sec."
-                sleep 2
-                puts "Retrying"
-                puts
-                retry
-              end
-              
-              raise e
-            ensure
-              debug "Removing thread #{Thread.current.__id__}"
-              @threads.delete(Thread.current)
-              
-              @lock.synchronize do
-                ActiveRecord::Base.connection.close if ActiveRecord::Base.connection
-              end
-            end
-          end
-        end
-        
-        @lock_threads.synchronize do
-          threads << thread
-          @threads << thread
+
+        if threadded?
+          work_threadded(klass, models)
+        else
+          work_models_through_transaction(klass, models)
         end
       end
     end
-    
-    return {
-      :threads => threads
-    }
   end
-  
-  #Waits for any remaining running threads.
+
+  # Waits for any remaining running threads.
   def join
-    @lock_threads.synchronize do
-      @threads.each do |thread|
-        thread.join
-      end
+    threads_to_join = @lock_threads.synchronize { @threads.clone }
+
+    debug "Threads to join: #{threads_to_join}" if @debug
+    threads_to_join.each do |thread|
+      thread.join
     end
   end
-  
+
+  def threadded?
+    @args[:threadded]
+  end
+
 private
-  
+
+  def parse_and_set_args
+    @models = {}
+    @threads = []
+    @count = 0
+    @lock = Monitor.new
+    @lock_threads = Monitor.new
+    @lock_models = {}
+    @max_running_threads = @args[:max_running_threads].to_i
+    @transaction_size = @args[:transaction_size].to_i
+    @debug = @args[:debug]
+  end
+
   def debug(str)
-    puts "{ActiveRecordTransactioner}: #{str}" if @debug
+    print "{ActiveRecordTransactioner}: #{str}\n" if @debug
   end
-  
+
   def wait_for_threads
     break_loop = false
     while !break_loop
-      debug "Trying to lock..." if @debug
-      @lock.synchronize do
-        debug "Running threads: #{@threads.length} / #{@args[:max_running_threads]}"
-        if @threads.length < @args[:max_running_threads]
-          break_loop = true
-        else
-          debug "Waiting for threads #{@threads.length} / #{@args[:max_running_threads]}" if @debug
-        end
+      debug "Running threads: #{@threads.length} / #{@max_running_threads}" if @debug
+      if allowed_to_start_new_thread?
+        break_loop = true
+      else
+        debug "Waiting for threads #{@threads.length} / #{@max_running_threads}" if @debug
       end
-      
-      sleep 0.2
+
+      sleep 0.2 unless break_loop
     end
-    
+
     debug "Done waiting." if @debug
   end
-end
+
+  def work_models_through_transaction(klass, models)
+    debug "Synchronizing model: #{klass.name}"
+
+    @lock_models[klass].synchronize do
+      debug "Opening new transaction by using '#{@args[:transaction_method]}'." if @debug
+
+      klass.__send__(@args[:transaction_method]) do
+        debug "Going through models." if @debug
+        models.each do |work|
+          debug work if @debug
+
+          if work[:type] == :save!
+            validate = work.key?(:validate) ? work[:validate] : true
+            work[:model].save! validate: validate
+          elsif work[:type] == :destroy!
+            work[:model].destroy!
+          else
+            raise "Invalid type: '#{work[:type]}'."
+          end
+        end
+
+        debug "Done working with models." if @debug
+      end
+    end
+  end
+
+  def work_threadded(klass, models)
+    @lock_threads.synchronize do
+      @threads << Thread.new do
+        begin
+          ActiveRecord::Base.connection_pool.with_connection do
+            work_models_through_transaction(klass, models)
+          end
+        rescue => e
+          pute e.inspect
+          puts e.backtrace
+
+          raise e
+        ensure
+          debug "Removing thread #{Thread.current.__id__}" if @debug
+          @lock_threads.synchronize { @threads.delete(Thread.current) }
+
+          debug "Threads count after remove: #{@threads.length}" if @debug
+        end
+      end
+    end
+
+    debug "Threads-count after started to work: #{@threads.length}"
+  end
+
+  def should_flush?
+    @count >= @transaction_size
+  end
+
+  def allowed_to_start_new_thread?
+    @lock_threads.synchronize { return @threads.length < @max_running_threads }
+  end
+end