in-parallel 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6277b0e376bda7d26d7f16760f16764569bdf01
-  data.tar.gz: f0798ecc56cd7e02cd1784fbc28f4b19a3e76118
+  metadata.gz: 616a0cfcbc49b019d69c306e9e919a86efdd9fee
+  data.tar.gz: 4e7aba20c6ca158d124242c74ce44ca59fbf9179
 SHA512:
-  metadata.gz: b3cb0370b0254ce1a801b32d7fcab2bb80acfeec6d0253a8752560c1da8ddf53de94e8a71d3e61369d204be44617451d26f909126ee484b61d0302c1b47d377d
-  data.tar.gz: 2f769c82a0fb813eb3ebfbeb0f09a8fe1a00086ea1e0220bca5913c1c47d5a617d625070627d9e7a619fdb42aeb9a370c9a6aedb53b333111fee2d47840644cc
+  metadata.gz: d9e961955959052dd40268155c142deefa2950145519d9ba1d778ac18c7dfcf256e66328ec55ef08c1fb0e10ad41a81760154e86f986240082055a2c024b3363
+  data.tar.gz: 03ea21bf0625a57e368595faf8bbdf8a5bfed798a4663e43e92da26f89e793b897b1a175824f61a355e84158a3abde04bae7fba10a35bbbecdc8772345e757a3

data/README.md

@@ -1,19 +1,20 @@
 # in-parallel
 A lightweight Ruby library with very simple syntax, making use of process.fork for parallelization
 
-Other popular Ruby librarys that do parallel execution support one primary use case - crunching through a large queue of small tasks as quickly and efficiently as possible.  This library primarily supports the use case of executing a few larger tasks in parallel and managing the stdout and return values to make it easy to understand which processes are logging what, and what the outcome of the execution was. This library was created to be used by Puppet's Beaker test framework to enable parallel execution of some of the framework's tasks, and allow people within thier tests to execute code in parallel when wanted.  This solution does not check to see how many processors you have, it just forks as many processes as you ask for.  That means that it will handle a handful of parallel processes well, but could definitely overload your system with ruby processes if you try to spin up a LOT of processes.  If you're looking for something simple and light-weight and on either linux or mac (forking processes is not supported on Windows), then this solution could be what you want.
+Other popular Ruby libraries that do parallel execution support one primary use case - crunching through a large queue of small tasks as quickly and efficiently as possible.  This library primarily supports the use case of executing a few larger tasks in parallel and managing the stdout and return values to make it easy to understand which processes are logging what, and what the outcome of the execution was. This library was created to be used by Puppet's Beaker test framework to enable parallel execution of some of the framework's tasks, and allow people within thier tests to execute code in parallel when wanted.  This solution does not check to see how many processors you have, it just forks as many processes as you ask for.  That means that it will handle a handful of parallel processes well, but could definitely overload your system with ruby processes if you try to spin up a LOT of processes.  If you're looking for something simple and light-weight and on either linux or mac (forking processes is not supported on Windows), then this solution could be what you want.
 
 If you are looking for something to support executing a lot of tasks in parallel as efficiently as possible, you should take a look at the [parallel](https://github.com/grosser/parallel) project.
 
 ## Methods:
 
-### run_in_parallel(&block)
+### run_in_parallel(timeout=nil, kill_all_on_error = false, &block)
 1. You can put whatever methods you want to execute in parallel into a block, and each method will be executed in parallel (unless the method is defined in kernel). 
-  1. Any methods further down the stack won't be affected, only the ones directly within the block.  
+    1. Any methods further down the stack won't be affected, only the ones directly within the block.
 2. You can assign the results to instance variables and it just works, no dealing with an array or map of results.
 3. Log STDOUT and STDERR chunked per process to the console so that it is easy to see what happened in which process.
 4. Waits for each process in realtime and logs immediately upon completion of each process
-5. If an exception is raised by a child process, it will immediately be re-raised in the primary process and kill all other still running child processes
+5. If an exception is raised by a child process, it will optionally (kill_all_on_error) be re-raised in the primary process and kill all other still running child processes. The default will wait for all processes to complete execution before re-raising any unhandled exception from the child processes.
+6. Times out by default at 30 minutes. Timeout default can be changed with InParallel::InParallelExecutor.parallel_default_timeout=X, or you can set the timeout param when calling the method
 
 ```ruby
   def method_with_param(name)
@@ -55,6 +56,38 @@ hello world
 hello world, bar
 ```
 
+### Enumerable.each_in_parallel(identifier=nil, timeout=(InParallel::InParallelExecutor.timeout), kill_all_on_error = false, &block)
+1. This is very similar to other solutions, except that it directly extends the Enumerable class with an each_in_parallel method, giving you the ability to pretty simply spawn a process for any item in an array or map.
+2. Identifies the block location (or caller location if the block does not have a source_location) in the console log to make it clear which block is being executed
+3. identifier param is only for logging, otherwise it will use the block source location.
+4. If an exception is raised by a child process, it will optionally (kill_all_on_error) be re-raised in the primary process and kill all other still running child processes. The default will wait for all processes to complete execution before re-raising any unhandled exception from the child processes.
+5. Times out by default at 30 minutes. Timeout default can be changed with InParallel::InParallelExecutor.parallel_default_timeout=X, or you can set the timeout param when calling the method
+
+```ruby
+  ["foo", "bar", "baz"].each_in_parallel { |item|
+    puts item
+  }
+
+```
+STDOUT:
+```
+'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51600'
+'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51601'
+'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51602'
+
+------ Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51600
+foo
+------ Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51600
+
+------ Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51601
+bar
+------ Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51601
+
+------ Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51602
+baz
+------ Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51602
+```
+
 ### run_in_background(ignore_results = true, &block)
 1. This does basically the same thing as run_in_parallel, except it does not wait for execution of all processes to complete, it returns immediately.
 2. You can optionally ignore results completely (default) or delay evaluating the results until later
@@ -101,31 +134,7 @@ hello world, bar
   
 ```
 
-### Enumerable.each_in_parallel(&block)
-1. This is very similar to other solutions, except that it directly extends the Enumerable class with an each_in_parallel method, giving you the ability to pretty simply spawn a process for any item in an array or map.
-2. Identifies the block location (or caller location if the block does not have a source_location) in the console log to make it clear which block is being executed
-
-```ruby
-  ["foo", "bar", "baz"].each_in_parallel { |item|
-    puts |item|
-  }
-  
-```
-STDOUT:
-```
-'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51600'
-'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51601'
-'each_in_parallel' spawned process for '/Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>'' - PID = '51602'
-
------- Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51600
-foo
------- Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51600
-
------- Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51601
-bar
------- Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51601
-
------- Begin output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51602
-baz
------- Completed output for /Users/samwoods/parallel_test/test.rb:77:in `block (2 levels) in <top (required)>' - 51602
-```
+### wait_for_processes(timeout=nil, kill_all_on_error = false)
+1. Used only after run_in_background with ignore_results=false
+2. Optional args for timeout and kill_all_on_error
+3. See run_in_background for examples

data/in_parallel/version.rb

@@ -1,3 +1,3 @@
 module InParallel
-  VERSION = Version = '0.1.9'
+  VERSION = Version = '0.1.10'
 end

data/lib/in_parallel.rb

@@ -1,11 +1,17 @@
+require_relative 'parallel_logger'
 require_relative 'parallel_enumerable'
+require 'tempfile'
+
 module InParallel
+  include ParallelLogger
+
   class InParallelExecutor
     # How many seconds between outputting to stdout that we are waiting for child processes.
     # 0 or < 0 means no signaling.
-    @@signal_interval = 30
-    @@timeout = 1800
-    @@process_infos = []
+    @@parallel_signal_interval = 30
+    @@parallel_default_timeout = 1800
+
+    @@process_infos            = []
     def self.process_infos
       @@process_infos
     end
@@ -21,44 +27,56 @@ module InParallel
       @@main_pid
     end
 
-    def self.timeout
-      @@timeout
+    def self.parallel_default_timeout
+      @@parallel_default_timeout
+    end
+
+    def self.parallel_default_timeout=(value)
+      @@parallel_default_timeout = value
+    end
+
+    def self.logger
+      @@logger
     end
 
-    def self.timeout=(value)
-      @@timeout = value
+    def self.logger=(value)
+      @@logger = value
     end
 
+    # Runs all methods within the block in parallel and waits for them to complete
+    #
     # Example - will spawn 2 processes, (1 for each method) wait until they both complete, and log STDOUT:
-    # InParallel.run_in_parallel {
-    #   @result_1 = method1
-    #   @result_2 = method2
-    # }
+    #   InParallel.run_in_parallel {
+    #     @result_1 = method1
+    #     @result_2 = method2
+    #   }
     # NOTE: Only supports assigning instance variables within the block, not local variables
-    def self.run_in_parallel(timeout = @@timeout, kill_all_on_error = false, &block)
-      if Process.respond_to?(:fork)
+    def self.run_in_parallel(timeout = @@parallel_default_timeout, kill_all_on_error = false, &block)
+      if fork_supported?
         proxy = BlankBindingParallelProxy.new(block.binding)
         proxy.instance_eval(&block)
         return wait_for_processes(proxy, block.binding, timeout, kill_all_on_error)
       end
-      puts 'Warning: Fork is not supported on this OS, executing block normally'
+      # if fork is not supported
       block.call
     end
 
+    # Runs all methods within the block in parallel in the background
+    #
     # Example - Will spawn a process in the background to run puppet agent on two agents and return immediately:
-    # Parallel.run_in_background {
-    #   @result_1 = method1
-    #   @result_2 = method2
-    # }
-    # # Do something else here before waiting for the process to complete
+    #   Parallel.run_in_background {
+    #     @result_1 = method1
+    #     @result_2 = method2
+    #   }
+    #   # Do something else here before waiting for the process to complete
     #
-    # # Optionally wait for the processes to complete before continuing.
-    # # Otherwise use run_in_background(true) to clean up the process status and output immediately.
-    # wait_for_processes(self)
-    # NOTE: must call get_background_results to allow instance variables in calling object to be set,
-    # otherwise @result_1 will evaluate to "unresolved_parallel_result_0"
+    #   # Optionally wait for the processes to complete before continuing.
+    #   # Otherwise use run_in_background(true) to clean up the process status and output immediately.
+    #   wait_for_processes(self)
+    #
+    # NOTE: must call get_background_results to allow instance variables in calling object to be set, otherwise @result_1 will evaluate to "unresolved_parallel_result_0"
     def self.run_in_background(ignore_result = true, &block)
-      if Process.respond_to?(:fork)
+      if fork_supported?
         proxy = BlankBindingParallelProxy.new(block.binding)
         proxy.instance_eval(&block)
 
@@ -71,25 +89,22 @@ module InParallel
         end
         return
       end
-      puts 'Warning: Fork is not supported on this OS, executing block normally'
+      # if fork is not supported
       result = block.call
       return nil if ignore_result
       result
     end
 
-    # Waits for all processes to complete and logs STDOUT and STDERR in chunks from any processes
-    # that were triggered from this Parallel class
-    # @param [Object] proxy - The instance of the proxy class that the method was executed within
-    # (probably only useful when called by run_in_background)
-    # @param [Object] binding - The binding of the block to assign return values to instance variables
-    # (probably only useful when called by run_in_background)
+    # Waits for all processes to complete and logs STDOUT and STDERR in chunks from any processes that were triggered from this Parallel class
+    # @param [Object] proxy - The instance of the proxy class that the method was executed within (probably only useful when called by run_in_background)
+    # @param [Object] binding - The binding of the block to assign return values to instance variables (probably only useful when called by run_in_background)
     # @param [Int] timeout Time in seconds to wait before giving up on a child process
-    # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately -
-    # killing all other forked processes - when one process errors.
+    # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately - killing all other forked processes - when one process errors.
     def self.wait_for_processes(proxy = self, binding = nil, timeout = nil, kill_all_on_error = false)
       raise_error = nil
-      timeout ||= @@timeout
+      timeout ||= @@parallel_default_timeout
       trap(:INT) do
+        # Can't use logger inside of trap
         puts "Warning, recieved interrupt.  Processing child results and exiting."
         kill_child_processes
       end
@@ -100,8 +115,8 @@ module InParallel
       start_time = Time.now
       timer = start_time
       while !@@process_infos.empty? do
-        if @@signal_interval > 0 && Time.now > timer + @@signal_interval
-          puts 'Waiting for child processes.'
+        if @@parallel_signal_interval > 0 && Time.now > timer + @@parallel_signal_interval
+          @@logger.debug 'Waiting for child processes.'
           timer = Time.now
         end
         if Time.now > start_time + timeout
@@ -116,21 +131,23 @@ module InParallel
             # the process completed, get the result and rethrow on error.
             begin
               # Print the STDOUT and STDERR for each process with signals for start and end
-              puts "\n------ Begin output for #{process_info[:method_sym]} - #{process_info[:pid]}\n"
-              puts File.new(process_info[:std_out], 'r').readlines
-              puts "------ Completed output for #{process_info[:method_sym]} - #{process_info[:pid]}\n"
+              @@logger.info "------ Begin output for #{process_info[:method_sym]} - #{process_info[:pid]}"
+              # Content from the other thread will already be pre-pended with log stuff (info, warn, date/time, etc)
+              # So don't use logger, just use puts.
+              puts "  " + File.new(process_info[:std_out], 'r').readlines.join("  ")
+              @@logger.info "------ Completed output for #{process_info[:method_sym]} - #{process_info[:pid]}"
               result = process_info[:result].read
               marshalled_result = (result.nil? || result.empty?) ? result : Marshal.load(result)
+              # Kill all other processes and let them log their stdout before re-raising
+              # if a child process raised an error.
               if marshalled_result.is_a?(Exception)
                 raise_error = marshalled_result.dup
                 kill_child_processes if kill_all_on_error
                 marshalled_result = nil
               end
               results_map[process_info[:index]] = {process_info[:tmp_result] => marshalled_result}
-              File.delete(process_info[:std_out])
-              # Kill all other processes and let them log their stdout before re-raising
-              # if a child process raised an error.
             ensure
+              File.delete(process_info[:std_out]) if File.exists?(process_info[:std_out])
               # close the read end pipe
               process_info[:result].close unless process_info[:result].closed?
               @@process_infos.delete(process_info)
@@ -164,21 +181,22 @@ module InParallel
       ret_val = nil
       # Communicate the return value of the method or block
       read_result, write_result = IO.pipe
-      Dir.mkdir('tmp') unless Dir.exists? 'tmp'
       pid = fork do
+        Dir.mkdir('tmp') unless Dir.exists? 'tmp'
+        stdout_file = File.new("tmp/pp_#{Process.pid}", 'w')
         exit_status = 0
         trap(:INT) do
-          puts("Warning: Interrupt received in child process; exiting #{Process.pid}")
+          # Can't use logger inside of trap
+          puts "Warning: Interrupt received in child process; exiting #{Process.pid}"
           kill_child_processes
           return
         end
-        write_file = File.new("tmp/parallel_process_#{Process.pid}", 'w')
 
         # IO buffer is 64kb, which isn't much... if debug logging is turned on,
         # this can be exceeded before a process completes.
         # Storing output in file rather than using IO.pipe
-        STDOUT.reopen(write_file)
-        STDERR.reopen(write_file)
+        STDOUT.reopen(stdout_file)
+        STDERR.reopen(stdout_file)
 
         begin
           # close subprocess's copy of read_result since it only needs to write
@@ -191,7 +209,7 @@ module InParallel
             begin
               ret_val = ret_val.dup
             rescue StandardError => err
-              puts "Warning: return value from child process #{ret_val} " +
+              @@logger.warn "Warning: return value from child process #{ret_val} " +
                        "could not be transferred to parent process: #{err.message}"
             end
           end
@@ -199,11 +217,11 @@ module InParallel
           begin
             Marshal.dump(ret_val, write_result) unless ret_val.nil?
           rescue StandardError => err
-            puts "Warning: return value from child process #{ret_val} " +
+            @@logger.warn "Warning: return value from child process #{ret_val} " +
                      "could not be transferred to parent process: #{err.message}"
           end
         rescue Exception => err
-          puts "Error in process #{pid}: #{err.message}"
+          @@logger.error "Error in process #{pid}: #{err.message}"
           # Return the error if an error is rescued so we can re-throw in the main process.
           Marshal.dump(err, write_result)
           exit_status = 1
@@ -212,6 +230,8 @@ module InParallel
           exit exit_status
         end
       end
+
+      @@logger.info "Forked process for #{method_sym} - PID = '#{pid}'"
       write_result.close
       # Process.detach returns a thread that will be nil if the process is still running and thr if not.
       # This allows us to check to see if processes have exited without having to call the blocking Process.wait functions.
@@ -220,7 +240,7 @@ module InParallel
       process_info = { :wait_thread => wait_thread,
                        :pid => pid,
                        :method_sym => method_sym,
-                       :std_out => "tmp/parallel_process_#{pid}",
+                       :std_out => "tmp/pp_#{pid}",
                        :result => read_result,
                        :tmp_result => "unresolved_parallel_result_#{@@result_id}",
                        :index => @@process_infos.count }
@@ -229,6 +249,12 @@ module InParallel
       process_info
     end
 
+    def self.fork_supported?
+      @@supported ||= Process.respond_to?(:fork)
+      @@logger.warn 'Warning: Fork is not supported on this OS, executing block normally' unless @@supported
+      @@supported
+    end
+
     def self.kill_child_processes
       @@process_infos.each { |process_info|
         # Send INT to each child process so it returns and can print stdout and stderr to console before exiting.
@@ -276,49 +302,65 @@ module InParallel
       def method_missing(method_sym, *args, &block)
         if InParallelExecutor.main_pid == ::Process.pid
           out = InParallelExecutor._execute_in_parallel("'#{method_sym.to_s}' #{caller_locations[0].to_s}", @object.eval('self')) {send(method_sym, *args, &block)}
-          puts "Forked process for '#{method_sym}' - PID = '#{out[:pid]}'\n"
           out[:tmp_result]
         end
       end
     end
   end
 
-  # Executes each method within a block in a different process
+  InParallelExecutor.logger = @logger
+
+  def parallel_signal_interval
+    InParallelExecutor.parallel_signal_interval
+  end
+
+  def parallel_signal_interval=(value)
+    InParallelExecutor.parallel_signal_interval = value
+  end
+
+  def parallel_default_timeout
+    InParallelExecutor.parallel_default_timeout
+  end
+
+  def parallel_default_timeout=(value)
+    InParallelExecutor.parallel_default_timeout = value
+  end
+
+  # Executes each method within a block in a different process.
+  #
   # Example - Will spawn a process in the background to execute each method
-  # Parallel.run_in_parallel {
-  #   @result_1 = method1
-  #   @result_2 = method2
-  # }
-  # NOTE - Only instance variables can be assigned the return values of the methods within the block.
-  # Local variables will not be assigned any values.
+  #   Parallel.run_in_parallel {
+  #     @result_1 = method1
+  #     @result_2 = method2
+  #   }
+  # NOTE - Only instance variables can be assigned the return values of the methods within the block. Local variables will not be assigned any values.
   # @param [Int] timeout Time in seconds to wait before giving up on a child process
-  # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately -
-  # killing all other forked processes - when one process errors.
+  # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately - killing all other forked processes - when one process errors.
   # @param [Block] block This method will yield to a block of code passed by the caller
   # @return [Array<Result>, Result] the return values of each method within the block
   def run_in_parallel(timeout=nil, kill_all_on_error = false, &block)
-    timeout ||= InParallelExecutor.timeout
+    timeout ||= InParallelExecutor.parallel_default_timeout
     InParallelExecutor.run_in_parallel(timeout, kill_all_on_error, &block)
   end
 
-  # Forks a process for each method within a block and returns immediately
+  # Forks a process for each method within a block and returns immediately.
+  #
   # Example 1 - Will fork a process in the background to execute each method and return immediately:
-  # Parallel.run_in_background {
-  #   @result_1 = method1
-  #   @result_2 = method2
-  # }
+  #   Parallel.run_in_background {
+  #     @result_1 = method1
+  #     @result_2 = method2
+  #   }
   #
   # Example 2 - Will fork a process in the background to execute each method, return immediately, then later
   # wait for the process to complete, printing it's STDOUT and assigning return values to instance variables:
-  # Parallel.run_in_background(false) {
-  #   @result_1 = method1
-  #   @result_2 = method2
-  # }
-  # # Do something else here before waiting for the process to complete
+  #   Parallel.run_in_background(false) {
+  #     @result_1 = method1
+  #     @result_2 = method2
+  #   }
+  #   # Do something else here before waiting for the process to complete
   #
-  # wait_for_processes
-  # NOTE: must call wait_for_processes to allow instance variables within the block to be set,
-  # otherwise results will evaluate to "unresolved_parallel_result_X"
+  #   wait_for_processes
+  # NOTE: must call wait_for_processes to allow instance variables within the block to be set, otherwise results will evaluate to "unresolved_parallel_result_X"
   # @param [Boolean] ignore_result True if you do not care about the STDOUT or return value of the methods executing in the background
   # @param [Block] block This method will yield to a block of code passed by the caller
   # @return [Array<Result>, Result] the return values of each method within the block
@@ -326,14 +368,12 @@ module InParallel
     InParallelExecutor.run_in_background(ignore_result, &block)
   end
 
-  # Waits for all processes started by run_in_background to complete execution, then prints STDOUT
-  # and assigns return values to instance variables.  See :run_in_background
+  # Waits for all processes started by run_in_background to complete execution, then prints STDOUT and assigns return values to instance variables.  See :run_in_background
   # @param [Int] timeout Time in seconds to wait before giving up on a child process
-  # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately -
-  # killing all other forked processes - when one process errors.
+  # @param [Boolean] kill_all_on_error Whether to wait for all processes to complete, or fail immediately - killing all other forked processes - when one process errors.
   # @return [Array<Result>, Result] the temporary return values of each method within the block
   def wait_for_processes(timeout=nil, kill_all_on_error = false)
-    timeout ||= InParallelExecutor.timeout
+    timeout ||= InParallelExecutor.parallel_default_timeout
     InParallelExecutor.wait_for_processes(nil, nil, timeout, kill_all_on_error)
   end
 end

data/lib/parallel_enumerable.rb

@@ -1,26 +1,25 @@
 # Extending Enumerable to make it easy to do any .each in parallel
 module Enumerable
   # Executes each iteration of the block in parallel
-  # Example - Will execute each iteration in a separate process, in parallel,
-  # log STDOUT per process, and return an array of results.
-  # my_array = [1,2,3]
-  # my_array.each_in_parallel { |int|
-  #   my_method(int)
-  # }
+  #
+  # Example - Will execute each iteration in a separate process, in parallel, log STDOUT per process, and return an array of results.
+  #   my_array = [1,2,3]
+  #   my_array.each_in_parallel { |int|
+  #     my_method(int)
+  #   }
   # @param [String] identifier - Optional identifier for logging purposes only. Will use the block location by default.
   # @param [Int] timeout - Seconds to wait for a forked process to complete before timing out
   # @return [Array<Object>] results - the return value of each block execution.
-  def each_in_parallel(identifier=nil, timeout=(InParallel::InParallelExecutor.timeout), kill_all_on_error = false, &block)
-    if Process.respond_to?(:fork) && count > 1
+  def each_in_parallel(identifier=nil, timeout=(InParallel::InParallelExecutor.parallel_default_timeout), kill_all_on_error = false, &block)
+    if InParallel::InParallelExecutor.fork_supported? && count > 1
       identifier ||= "#{caller_locations[0]}"
       each do |item|
         out = InParallel::InParallelExecutor._execute_in_parallel(identifier) {block.call(item)}
-        puts "'each_in_parallel' forked process for '#{identifier}' - PID = '#{out[:pid]}'\n"
       end
       # return the array of values, no need to look up from the map.
       return InParallel::InParallelExecutor.wait_for_processes(nil, block.binding, timeout, kill_all_on_error)
     end
-    puts 'Warning: Fork is not supported on this OS, executing block normally' unless Process.respond_to? :fork
+    # If fork is not supported
     block.call
     each(&block)
   end

data/lib/parallel_logger.rb

@@ -0,0 +1,13 @@
+require 'logger'
+module InParallel
+  module ParallelLogger
+    def self.included(base)
+      # Use existing logger if it is defined
+      unless(base.instance_variables.include?(:@logger) && base.logger)
+        logger = Logger.new(STDOUT)
+        logger.send(:extend, self)
+        base.instance_variable_set(:@logger, logger)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: in-parallel
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - samwoods1
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,7 @@ files:
 - in_parallel/version.rb
 - lib/in_parallel.rb
 - lib/parallel_enumerable.rb
+- lib/parallel_logger.rb
 homepage: https://github.com/samwoods1/in-parallel
 licenses:
 - MIT