parallel_minion 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 540c677d0eab24f63240820396a79c81beaf12fd
-  data.tar.gz: 5e523e81bb240522758a1a2ef52b9ccfaa67ecab
+  metadata.gz: c4ec6fafacfe5cf2b3e090a1e1ed733fd6c3bc33
+  data.tar.gz: a054a763962d6ee10fb8bc75587ec4d1c5f3d456
 SHA512:
-  metadata.gz: b509dc355be13737e83c715479d660dfc390a0fd0fb3efc0d9f19b4c29d1c51f8009ed09f8f889d714ad1aff46a2a9735f270691cb30ba02c0004cf1c908611f
-  data.tar.gz: 299fb7d5ff78e5e2ebeed0db274f6481f258afc9d5b82bb2ceaeb6265c2fb68b2c41f2f2231c9627fe3d7a97b51a1650694886d51a3b5c3888b61970c3277865
+  metadata.gz: 13909e2ad5221826dd9ac6cbbd15364566e4cf6b76fc33bc77d7cc8c35acc6ddb06cc3b53845bb6df053b031a13fb20808ce10c7e2f7bbb141912e2a86a03aff
+  data.tar.gz: 01b7b72f77160109e4bfa9ab995c6f98be128a7e837bc284d3932f399cdae9389b866d83a534d5ec618425c201d3607d5ff19b06bf803a3054da4edc409bcaa5

data/README.md

@@ -15,9 +15,11 @@ existing code to use minions.
 ## Example
 
 ```ruby
-minion = ParallelMinion::Minion.new(10.days.ago,
-            description: 'Doing something else in parallel',
-            timeout: 1000) do |date|
+minion = ParallelMinion::Minion.new(
+  10.days.ago,
+  description: 'Doing something else in parallel',
+  timeout:     1000
+) do |date|
   MyTable.where('created_at <= ?', date).count
 end
 
@@ -59,7 +61,7 @@ This project uses [Semantic Versioning](http://semver.org/).
 
 ## License
 
-Copyright 2013, 2014, 2105 Reid Morrison
+Copyright 2013, 2014, 2015, 2016, 2017 Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,28 +1,31 @@
-require 'rake/clean'
-require 'rake/testtask'
+# Setup bundler to avoid having to run bundle exec all the time.
+require 'rubygems'
+require 'bundler/setup'
 
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require 'parallel_minion/version'
+require 'rake/testtask'
+require_relative 'lib/parallel_minion/version'
 
 task :gem do
-  system "gem build parallel_minion.gemspec"
+  system 'gem build parallel_minion.gemspec'
 end
 
 task :publish => :gem do
   system "git tag -a v#{ParallelMinion::VERSION} -m 'Tagging #{ParallelMinion::VERSION}'"
-  system "git push --tags"
+  system 'git push --tags'
   system "gem push parallel_minion-#{ParallelMinion::VERSION}.gem"
   system "rm parallel_minion-#{ParallelMinion::VERSION}.gem"
 end
 
-desc "Run Test Suite"
-task :test do
-  Rake::TestTask.new(:functional) do |t|
-    t.test_files = FileList['test/*_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::Task['functional'].invoke
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
 end
 
-task :default => :test
+# By default run tests against all appraisals
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  require 'appraisal'
+  task default: :appraisal
+else
+  task default: :test
+end

data/lib/parallel_minion.rb

@@ -2,7 +2,7 @@ require 'thread'
 require 'semantic_logger'
 
 module ParallelMinion
-  autoload :Minion,    'parallel_minion/minion'
+  autoload :Minion, 'parallel_minion/minion'
 end
 
 require 'parallel_minion/railtie' if defined?(Rails)

data/lib/parallel_minion/minion.rb

@@ -19,26 +19,34 @@ module ParallelMinion
     # Returns nil if the minion is still running
     attr_reader :duration
 
+    # Metrics [String]
+    attr_reader :metric, :wait_metric
+
+    attr_reader :on_timeout, :log_exception, :start_time
+
     # Give an infinite amount of time to wait for a Minion to complete a task
     INFINITE = 0
 
-    # Sets whether minions are enabled to run in their own threads
-    #
-    # By Setting _enabled_ to false all Minions that have not yet been started
-    # will run in the thread from which it is created and not on its own thread
+    # Sets whether Minions should run in a separate thread.
     #
-    # This is useful:
-    # - to run tests under the Capybara gem
-    # - when debugging code so that all code is run sequentially in the current thread
-    #
-    # Note: Not recommended to set this setting to false in Production
+    # By Setting _enabled_ to false all Minions that have not yet been created
+    # will run in the thread in which it is created.
+    # - Development:
+    #    Use a debugger, since the code will run in the current thread.
+    # - Test:
+    #     Keep test execution in the current thread.
+    #     Supports rolling back database changes after each test, since all changes are
+    #     performed on the same database connection.
+    # - Production:
+    #     Batch processing in Rocket Job where throughput is more important than latency.
+    #       http://rocketjob.io
     def self.enabled=(enabled)
-      @@enabled = enabled
+      @enabled = enabled
     end
 
     # Returns whether minions are enabled to run in their own threads
     def self.enabled?
-      @@enabled
+      @enabled
     end
 
     # The list of classes for which the current scope must be copied into the
@@ -47,25 +55,85 @@ module ParallelMinion
     # Example:
     #   ...
     def self.scoped_classes
-      @@scoped_classes
+      @scoped_classes
     end
 
-    # Create a new thread and
-    #   Log the time for the thread to complete processing
-    #   The exception without stack trace is logged whenever an exception is
-    #   thrown in the thread
-    #   Re-raises any unhandled exception in the calling thread when it call #result
-    #   Copy the logging tags and specified ActiveRecord scopes to the new thread
+    def self.scoped_classes=(scoped_classes)
+      @scoped_classes = scoped_classes.dup
+    end
+
+    # Change the log level for the Started log message.
+    #
+    # Default: :info
+    #
+    # Valid levels:
+    #   :trace, :debug, :info, :warn, :error, :fatal
+    def self.started_log_level=(level)
+      raise(ArgumentError, "Invalid log level: #{level}") unless SemanticLogger::LEVELS.include?(level)
+      @started_log_level = level
+    end
+
+    def self.started_log_level
+      @started_log_level
+    end
+
+    # Change the log level for the Completed log message.
+    #
+    # Default: :info
+    #
+    # Valid levels:
+    #   :trace, :debug, :info, :warn, :error, :fatal
+    def self.completed_log_level=(level)
+      raise(ArgumentError, "Invalid log level: #{level}") unless SemanticLogger::LEVELS.include?(level)
+      @completed_log_level = level
+    end
+
+    def self.completed_log_level
+      @completed_log_level
+    end
+
+    self.started_log_level   = :info
+    self.completed_log_level = :info
+    self.enabled             = true
+    self.scoped_classes      = []
+    logger.name              = 'Minion'
+
+    # Create a new Minion
+    #
+    #   Creates a new thread and logs the time for the supplied block to complete processing.
+    #   The exception without stack trace is logged whenever an exception is thrown in the thread.
+    #
+    #   Re-raises any unhandled exception in the calling thread when `#result` is called.
+    #   Copies the logging tags and specified ActiveRecord scopes to the new thread.
     #
     # Parameters
+    #   *arguments
+    #     Any number of arguments can be supplied that are passed into the block
+    #     in the order they are listed.
+    #
+    #     Note:
+    #       All arguments must be supplied by copy and not by reference.
+    #       For example, use `#dup` to create copies of passed data.
+    #       Pass by copy is critical to prevent concurrency issues when multiple threads
+    #       attempt to update the same object at the same time.
+    #
+    #   Proc / lambda
+    #     A block of code must be supplied that the Minion will execute.
+    #
+    #     Note:
+    #       This block will be executed within the scope of the created minion instance
+    #       and _not_ within the scope of where the Proc/lambda was originally created.
+    #       This is done to force all parameters to be passed in explicitly
+    #       and should be read-only or duplicates of the original data.
+    #
     #   :description [String]
-    #     Description for this task that the Minion is performing
-    #     Put in the log file along with the time take to complete the task
+    #     Description for this task that the Minion is performing.
+    #     Written to the log file along with the time take to complete the task.
     #
     #   :timeout [Integer]
     #     Maximum amount of time in milli-seconds that the task may take to complete
-    #     before #result times out
-    #     Set to 0 to give the thread an infinite amount of time to complete
+    #     before #result times out.
+    #     Set to 0 to give the thread an infinite amount of time to complete.
     #     Default: 0 ( Wait forever )
     #
     #     Notes:
@@ -76,11 +144,6 @@ module ParallelMinion
     #       then :timeout is ignored and assumed to be Minion::INFINITE
     #       since the code is run in the calling thread when the Minion is created
     #
-    #   :enabled [Boolean]
-    #     Whether the minion should run in a separate thread
-    #     Not recommended in Production, but is useful for debugging purposes
-    #     Default: ParallelMinion::Minion.enabled?
-    #
     #   :on_timeout [Exception]
     #     The class to raise on the minion when the minion times out.
     #     By raising the exception on the running thread it ensures that the thread
@@ -92,21 +155,30 @@ module ParallelMinion
     #
     #     Note: :on_timeout has no effect if not #enabled?
     #
-    #   *args
-    #     Any number of arguments can be supplied that are passed into the block
-    #     in the order they are listed
-    #     It is recommended to duplicate and/or freeze objects passed as arguments
-    #     so that they are not modified at the same time by multiple threads
-    #     These arguments are accessible while and after the minion is running
-    #     by calling #arguments
+    #   :metric [String]
+    #     Name of the metric to forward to Semantic Logger when measuring the minion execution time.
+    #     Example: inquiry/address_cleansing
     #
-    #   Proc / lambda
-    #     A block of code must be supplied that the Minion will execute
-    #     NOTE: This block will be executed within the scope of the created minion
-    #           instance and _not_ within the scope of where the Proc/lambda was
-    #           originally created.
-    #           This is done to force all parameters to be passed in explicitly
-    #           and should be read-only or duplicates of the original data
+    #     When a metric is supplied the following metrics will also be generated:
+    #     - wait
+    #         Duration waiting for a minion to complete.
+    #
+    #     The additional metrics are added to the supplied metric name. For example:
+    #     - inquiry/address_cleansing/wait
+    #
+    #   :log_exception [Symbol]
+    #     Control whether or how an exception thrown in the block is
+    #     reported by Semantic Logger. Values:
+    #      :full
+    #        Log the exception class, message, and backtrace
+    #      :partial
+    #        Log the exception class and message. The backtrace will not be logged
+    #      :off
+    #        Any unhandled exception raised in the block will not be logged
+    #      Default: :partial
+    #
+    #   :enabled [Boolean]
+    #     Override the global setting: `ParallelMinion::Minion.enabled?` for this minion instance.
     #
     # The overhead for moving the task to a Minion (separate thread) vs running it
     # sequentially is about 0.3 ms if performing other tasks in-between starting
@@ -116,86 +188,32 @@ module ParallelMinion
     # code in-line:
     #   ParallelMinion::Minion.new(description: 'Count', timeout: 5) { 1 }.result
     #
-    # NOTE:
-    #   On JRuby it is very important to add the following setting to .jrubyrc
-    #       thread.pool.enabled=true
+    # Note:
+    #   On JRuby it is recommended to add the following setting to .jrubyrc
+    #     thread.pool.enabled=true
     #
     # Example:
     #   ParallelMinion::Minion.new(10.days.ago, description: 'Doing something else in parallel', timeout: 1000) do |date|
     #     MyTable.where('created_at <= ?', date).count
     #   end
-    def initialize(*args, &block)
-      raise "Missing mandatory block that Minion must perform" unless block
+    def initialize(*arguments, description: 'Minion', metric: nil, log_exception: nil, enabled: self.class.enabled?, timeout: INFINITE, on_timeout: nil, wait_metric: nil, &block)
+      raise 'Missing mandatory block that Minion must perform' unless block
       @start_time    = Time.now
       @exception     = nil
-      @arguments     = args.dup
-      options        = self.class.extract_options!(@arguments)
-      @timeout       = options.delete(:timeout).to_f
-      @description   = (options.delete(:description) || 'Minion').to_s
-      @metric        = options.delete(:metric)
-      @log_exception = options.delete(:log_exception)
-      @enabled       = options.delete(:enabled)
-      @enabled       = self.class.enabled? if @enabled.nil?
-      @on_timeout    = options.delete(:on_timeout)
-
-      # Warn about any unknown options.
-      options.each_pair do | key, val |
-        logger.warn "Ignoring unknown option: #{key.inspect} => #{val.inspect}"
-        warn "ParallelMinion::Minion Ignoring unknown option: #{key.inspect} => #{val.inspect}"
-      end
+      @arguments     = arguments
+      @timeout       = timeout.to_f
+      @description   = description.to_s
+      @metric        = metric
+      @log_exception = log_exception
+      @enabled       = enabled
+      @on_timeout    = on_timeout
 
-      # Run the supplied block of code in the current thread for testing or
-      # debugging purposes
-      if @enabled == false
-        begin
-          logger.info("Started in the current thread: #{@description}")
-          logger.benchmark_info("Completed in the current thread: #{@description}", log_exception: @log_exception, metric: @metric) do
-            @result = instance_exec(*@arguments, &block)
-          end
-        rescue Exception => exc
-          @exception = exc
-        ensure
-          @duration = Time.now - @start_time
-        end
-        return
-      end
+      @wait_metric   = (wait_metric || "#{metric}/wait") if @metric
 
-      tags = (logger.tags || []).dup
-
-      # Copy current scopes for new thread. Only applicable for AR models
-      scopes = self.class.current_scopes if defined?(ActiveRecord::Base)
-
-      @thread = Thread.new(*@arguments) do
-        # Copy logging tags from parent thread
-        logger.tagged(*tags) do
-          # Set the current thread name to the description for this Minion
-          # so that all log entries in this thread use this thread name
-          Thread.current.name = "#{@description}-#{Thread.current.object_id}"
-          logger.info("Started #{@description}")
-
-          begin
-            logger.benchmark_info("Completed #{@description}", log_exception: @log_exception, metric: @metric) do
-              # Use the current scope for the duration of the task execution
-              if scopes.nil? || (scopes.size == 0)
-                @result = instance_exec(*@arguments, &block)
-              else
-                # Each Class to scope requires passing a block to .scoping
-                proc = Proc.new { instance_exec(*@arguments, &block) }
-                first = scopes.shift
-                scopes.each {|scope| proc = Proc.new { scope.scoping(&proc) } }
-                @result = first.scoping(&proc)
-              end
-            end
-          rescue Exception => exc
-            @exception = exc
-            nil
-          ensure
-            # Return any database connections used by this thread back to the pool
-            ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
-            @duration = Time.now - @start_time
-          end
-        end
-      end
+      # When minion is disabled it is obvious in the logs since the name will now be 'Inline' instead of 'Minion'
+      self.logger    = SemanticLogger['Inline'] unless @enabled
+
+      @enabled ? run(&block) : run_inline(&block)
     end
 
     # Returns the result when the thread completes
@@ -207,10 +225,10 @@ module ParallelMinion
       # Return nil if Minion is still working and has time left to finish
       if working?
         ms = time_left
-        logger.benchmark_info("Waited for Minion to complete: #{@description}", min_duration: 0.01) do
-          if @thread.join(ms.nil? ? nil: ms / 1000).nil?
-            @thread.raise(@on_timeout.new("Minion: #{@description} timed out")) if @on_timeout
-            logger.warn("Timed out waiting for result from Minion: #{@description}")
+        logger.measure(self.class.completed_log_level, "Waited for Minion to complete: #{description}", min_duration: 0.01, metric: wait_metric) do
+          if @thread.join(ms.nil? ? nil : ms / 1000).nil?
+            @thread.raise(@on_timeout.new("Minion: #{description} timed out")) if @on_timeout
+            logger.warn("Timed out waiting for: #{description}")
             return
           end
         end
@@ -239,8 +257,8 @@ module ParallelMinion
     # Returns 0 if no time is left
     # Returns nil if their is no time limit. I.e. :timeout was set to Minion::INFINITE (infinite time left)
     def time_left
-      return nil if (@timeout == 0) || (@timeout == -1)
-      duration = @timeout - (Time.now - @start_time) * 1000
+      return nil if (timeout == 0) || (timeout == -1)
+      duration = timeout - (Time.now - start_time) * 1000
       duration <= 0 ? 0 : duration
     end
 
@@ -252,25 +270,78 @@ module ParallelMinion
     # Returns the current scopes for each of the models for which scopes will be
     # copied to the Minions
     if defined?(ActiveRecord)
-      if  ActiveRecord::VERSION::MAJOR >= 4
+      if ActiveRecord::VERSION::MAJOR >= 4
         def self.current_scopes
-          @@scoped_classes.collect {|klass| klass.all}
+          scoped_classes.collect { |klass| klass.all }
         end
       else
         def self.current_scopes
-          @@scoped_classes.collect {|klass| klass.scoped}
+          scoped_classes.collect { |klass| klass.scoped }
         end
       end
     end
 
-    protected
+    private
 
-    @@enabled = true
-    @@scoped_classes = []
+    # Run the supplied block of code in the current thread.
+    # Useful for debugging, testing, and when running in batch environments.
+    def run_inline(&block)
+      begin
+        logger.public_send(self.class.started_log_level, "Started #{@description}")
+        logger.measure(self.class.completed_log_level, "Completed #{@description}", log_exception: @log_exception, metric: metric) do
+          @result = instance_exec(*arguments, &block)
+        end
+      rescue Exception => exc
+        @exception = exc
+      ensure
+        @duration = Time.now - start_time
+      end
+    end
+
+    def run(&block)
+      # Capture tags from current thread
+      tags = SemanticLogger.tags
+      tags = tags.nil? || tags.empty? ? nil : tags.dup
+
+      named_tags = SemanticLogger.named_tags
+      named_tags = named_tags.nil? || named_tags.empty? ? nil : named_tags.dup
+
+      # Captures scopes from current thread. Only applicable for AR models
+      scopes     = self.class.current_scopes if defined?(ActiveRecord::Base)
+
+      @thread = Thread.new(*arguments) do
+        Thread.current.name = "#{description}-#{Thread.current.object_id}"
+
+        # Copy logging tags from parent thread, if any
+        proc                = Proc.new { run_in_scope(scopes, &block) }
+        proc2               = tags ? Proc.new { SemanticLogger.tagged(*tags, &proc) } : proc
+        proc3               = named_tags ? Proc.new { SemanticLogger.named_tagged(named_tags, &proc2) } : proc2
+
+        logger.public_send(self.class.started_log_level, "Started #{description}")
+        begin
+          logger.measure(self.class.completed_log_level, "Completed #{description}", log_exception: log_exception, metric: metric, &proc3)
+        rescue Exception => exc
+          @exception = exc
+          nil
+        ensure
+          @duration = Time.now - start_time
+          # Return any database connections used by this thread back to the pool
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+    end
 
-    # Extract options from a hash.
-    def self.extract_options!(args)
-      args.last.is_a?(Hash) ? args.pop : {}
+    def run_in_scope(scopes, &block)
+      if scopes.nil? || scopes.empty?
+        @result = instance_exec(*@arguments, &block)
+      else
+        # Use the captured scope when running the block.
+        # Each Class to scope requires passing a block to .scoping.
+        proc  = Proc.new { instance_exec(*@arguments, &block) }
+        first = scopes.shift
+        scopes.each { |scope| proc = Proc.new { scope.scoping(&proc) } }
+        @result = first.scoping(&proc)
+      end
     end
 
   end

data/lib/parallel_minion/railtie.rb

@@ -11,6 +11,14 @@ module ParallelMinion #:nodoc:
     #     # Run Minions in the current thread to make debugging easier
     #     config.parallel_minion.enabled = false
     #
+    #     # Change the log level for the started log messages to :debug,
+    #     # so that they do not show up in production when log level is :info.
+    #     config.parallel_minion.started_log_level = :debug
+    #
+    #     # Change the log level for the completed log messages to :debug,
+    #     # so that they do not show up in production when log level is :info.
+    #     config.parallel_minion.completed_log_level = :debug
+    #
     #     # Add a model so that its current scope is copied to the Minion
     #     config.after_initialize do
     #       # Perform in an after_initialize so that the model has been loaded

data/lib/parallel_minion/version.rb

@@ -1,3 +1,3 @@
 module ParallelMinion #:nodoc
-  VERSION = "1.1.0"
+  VERSION = '1.2.0'
 end

data/test/minion_scope_test.rb

@@ -1,18 +1,10 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-require 'rubygems'
+require_relative './test_helper'
 require 'erb'
-#require 'test/unit'
-# Since we want both the AR and Mongoid extensions loaded we need to require them first
 require 'active_record'
-require 'active_record/relation'
-# Should redefines Proc#bind so must include after Rails
-#require 'shoulda'
-#require 'parallel_minion'
 
-ActiveRecord::Base.logger = SemanticLogger[ActiveRecord]
+ActiveRecord::Base.logger         = SemanticLogger[ActiveRecord]
 ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/config/database.yml')).result)
-ActiveRecord::Base.establish_connection('test')
+ActiveRecord::Base.establish_connection(:test)
 
 ActiveRecord::Schema.define :version => 0 do
   create_table :people, :force => true do |t|
@@ -26,15 +18,14 @@ class Person < ActiveRecord::Base
 end
 
 class MinionScopeTest < Minitest::Test
-
-  context ParallelMinion::Minion do
+  describe ParallelMinion::Minion do
     [false, true].each do |enabled|
-      context ".new with enabled: #{enabled.inspect}" do
-        setup do
+      describe ".new with enabled: #{enabled.inspect}" do
+        before do
           Person.create(name: 'Jack', state: 'FL', zip_code: 38729)
           Person.create(name: 'John', state: 'FL', zip_code: 35363)
           Person.create(name: 'Jill', state: 'FL', zip_code: 73534)
-          Person.create(name: 'Joe',  state: 'NY', zip_code: 45325)
+          Person.create(name: 'Joe', state: 'NY', zip_code: 45325)
           Person.create(name: 'Jane', state: 'NY', zip_code: 45325)
           Person.create(name: 'James', state: 'CA', zip_code: 123123)
           # Instruct Minions to adhere to any dynamic scopes for Person model
@@ -42,13 +33,13 @@ class MinionScopeTest < Minitest::Test
           ParallelMinion::Minion.enabled = enabled
         end
 
-        teardown do
+        after do
           Person.destroy_all
           ParallelMinion::Minion.scoped_classes.clear
           SemanticLogger.flush
         end
 
-        should 'copy across model scope' do
+        it 'copy across model scope' do
           assert_equal 6, Person.count
 
           Person.unscoped.where(state: 'FL').scoping { Person.count }
@@ -65,4 +56,4 @@ class MinionScopeTest < Minitest::Test
       end
     end
   end
-end
+end

data/test/minion_test.rb

@@ -1,47 +1,53 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
+require_relative './test_helper'
 
 # Test ParallelMinion standalone without Rails
 # Run this test standalone to verify it has no Rails dependencies
 class MinionTest < Minitest::Test
   include SemanticLogger::Loggable
 
-  context ParallelMinion::Minion do
+  describe ParallelMinion::Minion do
 
     [false, true].each do |enabled|
-      context ".new with enabled: #{enabled.inspect}" do
-        setup do
+      describe enabled ? 'enabled' : 'disabled' do
+        before do
           ParallelMinion::Minion.enabled = enabled
-          $log_struct = nil
+          $log_structs                   = []
         end
 
-        should 'without parameters' do
+        it 'without parameters' do
           minion = ParallelMinion::Minion.new { 196 }
           assert_equal 196, minion.result
         end
 
-        should 'with a description' do
+        it 'with a description' do
           minion = ParallelMinion::Minion.new(description: 'Test') { 197 }
           assert_equal 197, minion.result
         end
 
-        should 'with an argument' do
-          p1 = { name: 198 }
+        it 'with an argument' do
+          p1     = {name: 198}
           minion = ParallelMinion::Minion.new(p1, description: 'Test') do |v|
             v[:name]
           end
           assert_equal 198, minion.result
         end
 
-        should 'raise exception' do
+        it 'raise exception' do
           minion = ParallelMinion::Minion.new(description: 'Test') { raise "An exception" }
           assert_raises RuntimeError do
             minion.result
           end
         end
 
+        it 'has correct logger name' do
+          minion = ParallelMinion::Minion.new { 196 }
+          name   = enabled ? 'Minion' : 'Inline'
+          assert_equal name, minion.logger.name
+        end
+
         # TODO Blocks still have access to their original scope if variables cannot be
         #      resolved first by the parameters, then by the values in Minion itself
-        #        should 'not have access to local variables' do
+        #        it 'not have access to local variables' do
         #          name = 'Jack'
         #          minion = ParallelMinion::Minion.new(description: 'Test') { puts name }
         #          assert_raises NameError do
@@ -49,11 +55,11 @@ class MinionTest < Minitest::Test
         #          end
         #        end
 
-        should 'run minion' do
-          hash = { value: 23 }
-          value = 47
+        it 'run minion' do
+          hash   = {value: 23}
+          value  = 47
           minion = ParallelMinion::Minion.new(hash, description: 'Test') do |h|
-            value = 321
+            value     = 321
             h[:value] = 123
             456
           end
@@ -62,10 +68,10 @@ class MinionTest < Minitest::Test
           assert_equal 321, value
         end
 
-        should 'copy across logging tags' do
+        it 'copy across logging tags' do
           minion = nil
-          logger.tagged('TAG') do
-            assert_equal 'TAG', logger.tags.last
+          SemanticLogger.tagged('TAG') do
+            assert_equal 'TAG', SemanticLogger.tags.last
             minion = ParallelMinion::Minion.new(description: 'Tag Test') do
               logger.tags.last
             end
@@ -73,27 +79,38 @@ class MinionTest < Minitest::Test
           assert_equal 'TAG', minion.result
         end
 
-        should 'include metric' do
-          metric_name = '/Custom/metric'
-          hash = { value: 23 }
-          value = 47
-          minion = ParallelMinion::Minion.new(hash, description: 'Test', metric: metric_name) do |h|
-            value = 321
+        it 'include metric' do
+          metric_name = 'model/method'
+          hash        = {value: 23}
+          value       = 47
+          minion      = ParallelMinion::Minion.new(hash, description: 'Test', metric: metric_name) do |h|
+            value     = 321
             h[:value] = 123
+            sleep 1
             456
           end
           assert_equal 456, minion.result
           assert_equal 123, hash[:value]
           assert_equal 321, value
           SemanticLogger.flush
-          assert_equal metric_name, $log_struct.metric
+          assert log = $log_structs.first, -> { $log_structs.ai }
+          if enabled
+            # Completed log message
+            assert_equal metric_name, log.metric, -> { $log_structs.ai }
+            # Wait log message
+            assert log = $log_structs.last, -> { $log_structs.ai }
+            assert_equal "#{metric_name}/wait", log.metric, -> { $log_structs.ai }
+          else
+            # Timeout and wait has no effect when run inline
+            assert_equal metric_name, log.metric, -> { $log_structs.ai }
+          end
         end
 
-        should 'handle multiple minions concurrently' do
+        it 'handle multiple minions concurrently' do
           # Start 10 minions
           minions = 10.times.collect do |i|
             # Each Minion returns its index in the collection
-            ParallelMinion::Minion.new(i, description: "Minion:#{i}") {|counter| counter }
+            ParallelMinion::Minion.new(i, description: "Minion:#{i}") { |counter| counter }
           end
           assert_equal 10, minions.count
           # Fetch the result from each Minion
@@ -102,58 +119,58 @@ class MinionTest < Minitest::Test
           end
         end
 
-        should 'timeout' do
-          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100) { sleep 1 }
+        it 'timeout' do
           if enabled
-            assert_equal nil, minion.result
+            minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100) { sleep 1 }
+            assert_nil minion.result
           end
         end
 
-        should 'timeout and terminate thread with Exception' do
-          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100, on_timeout: Timeout::Error) { sleep 1 }
+        it 'timeout and terminate thread with Exception' do
           if enabled
-            assert_equal nil, minion.result
+            minion = ParallelMinion::Minion.new(description: 'Test', timeout: 100, on_timeout: Timeout::Error) { sleep 1 }
+            assert_nil minion.result
             # Give time for thread to terminate
             sleep 0.1
             assert_equal Timeout::Error, minion.exception.class
             assert_equal false, minion.working?
-            assert_equal true,  minion.completed?
-            assert_equal true,  minion.failed?
-            assert_equal 0,     minion.time_left
+            assert_equal true, minion.completed?
+            assert_equal true, minion.failed?
+            assert_equal 0, minion.time_left
           end
         end
 
-        should 'make description instance variable available' do
+        it 'make description instance variable available' do
           minion = ParallelMinion::Minion.new(description: 'Test') do
             description
           end
           assert_equal 'Test', minion.result
         end
 
-        should 'make timeout instance variable available' do
-          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 1000 ) do
+        it 'make timeout instance variable available' do
+          minion = ParallelMinion::Minion.new(description: 'Test', timeout: 1000) do
             timeout
           end
           assert_equal 1000, minion.result
         end
 
-        should 'make enabled? method available' do
+        it 'make enabled? method available' do
           minion = ParallelMinion::Minion.new(description: 'Test') do
             enabled?
           end
           assert_equal enabled, minion.result
         end
 
-        should 'keep the original arguments' do
-          minion = ParallelMinion::Minion.new(1, 'data', 14.1, description: 'Test') do | num, str, float |
+        it 'keep the original arguments' do
+          minion = ParallelMinion::Minion.new(1, 'data', 14.1, description: 'Test') do |num, str, float|
             num + float
           end
           assert_equal 15.1, minion.result
-          assert_equal [ 1, 'data', 14.1 ], minion.arguments
+          assert_equal [1, 'data', 14.1], minion.arguments
         end
       end
 
     end
 
   end
-end
+end

data/test/test_helper.rb

@@ -1,19 +1,13 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 
 require 'minitest/autorun'
-require 'minitest/reporters'
-require 'minitest/stub_any_instance'
-require 'shoulda/context'
 require 'parallel_minion'
 require 'semantic_logger'
 
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-# Register an appender if one is not already registered
 SemanticLogger.default_level = :trace
-SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter) if SemanticLogger.appenders.size == 0
+SemanticLogger.add_appender(file_name: 'test.log', formatter: :color)
 
 # Setup global callback for metric so that it can be tested below
 SemanticLogger.on_metric do |log_struct|
-  $log_struct = log_struct.dup
+  ($log_structs ||= []) << log_struct.dup
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_minion
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-01 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
 description: Parallel Minion allows you to take existing blocks of code and wrap them
   in a minion so that they can run asynchronously in a separate thread
 email:
@@ -56,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Pragmatic approach to parallel and asynchronous processing in Ruby