rocketjob 5.4.0.beta2 → 6.0.0.rc3

data/lib/rocket_job/batch/statistics.rb

@@ -2,7 +2,11 @@ require "active_support/concern"
 
 module RocketJob
   module Batch
-    # Allow statistics to be gathered while a batch job is running
+    # Allow statistics to be gathered while a batch job is running.
+    #
+    # Notes:
+    # - Statistics for successfully processed records within a slice are saved.
+    # - Statistics gathered during a perform that then results in an exception are discarded.
     module Statistics
       extend ActiveSupport::Concern
 
@@ -45,34 +49,52 @@ module RocketJob
           last  = paths.pop
           return unless last
 
-          target = paths.inject(in_memory) { |target, key| target.key?(key) ? target[key] : target[key] = Hash.new(0) }
-          target[last] += increment
+          last_target = paths.inject(in_memory) do |target, sub_key|
+            target.key?(sub_key) ? target[sub_key] : target[sub_key] = Hash.new(0)
+          end
+          last_target[last] += increment
         end
       end
 
       included do
         field :statistics, type: Hash, default: -> { Hash.new(0) }
 
-        around_slice :statistics_capture
+        around_slice :rocket_job_statistics_capture
+        after_perform :rocket_job_statistics_commit
       end
 
       # Increment a statistic
       def statistics_inc(key, increment = 1)
         return if key.nil? || key == ""
 
-        # Being called within tests outside of a perform
-        @slice_statistics ||= Stats.new(new_record? ? statistics : nil)
-        key.is_a?(Hash) ? @slice_statistics.inc(key) : @slice_statistics.inc_key(key, increment)
+        (@rocket_job_perform_statistics ||= []) << (key.is_a?(Hash) ? key : [key, increment])
       end
 
       private
 
-      # Capture the number of successful and failed tradelines
-      # as well as those with notices and alerts.
-      def statistics_capture
-        @slice_statistics = Stats.new(new_record? ? statistics : nil)
+      def rocket_job_statistics_capture
+        @rocket_job_perform_statistics = nil
+        @rocket_job_slice_statistics   = nil
         yield
-        collection.update_one({_id: id}, {"$inc" => @slice_statistics.stats}) unless @slice_statistics.empty?
+      ensure
+        if @rocket_job_slice_statistics && !@rocket_job_slice_statistics.empty?
+          collection.update_one({_id: id}, {"$inc" => @rocket_job_slice_statistics.stats})
+        end
+      end
+
+      def rocket_job_slice_statistics
+        @rocket_job_slice_statistics ||= Stats.new(new_record? ? statistics : nil)
+      end
+
+      # Apply stats gathered during the perform to the slice level stats
+      def rocket_job_statistics_commit
+        return unless @rocket_job_perform_statistics
+
+        @rocket_job_perform_statistics.each do |key|
+          key.is_a?(Hash) ? rocket_job_slice_statistics.inc(key) : rocket_job_slice_statistics.inc_key(*key)
+        end
+
+        @rocket_job_perform_statistics = nil
       end
 
       # Overrides RocketJob::Batch::Logger#rocket_job_batch_log_payload

data/lib/rocket_job/batch/tabular.rb

@@ -12,6 +12,8 @@ module RocketJob
     # )
     #
     # tabular.render(row)
+    #
+    # @deprecated
     class Tabular
       autoload :Input, "rocket_job/batch/tabular/input"
       autoload :Output, "rocket_job/batch/tabular/output"

data/lib/rocket_job/batch/tabular/input.rb

@@ -3,15 +3,15 @@ require "active_support/concern"
 module RocketJob
   module Batch
     class Tabular
-      # For the simple case where all `input_categories` have the same format,
-      # If multiple input categories are used with different formats, then use IOStreams::Tabular directly
-      # instead of this plugin.
+      # @deprecated
       module Input
         extend ActiveSupport::Concern
 
         included do
+          warn "#{name} is using RocketJob::Batch::Tabular::Input which is deprecated"
+
           field :tabular_input_header, type: Array, class_attribute: true, user_editable: true
-          field :tabular_input_format, type: Symbol, default: :csv, class_attribute: true, user_editable: true
+          field :tabular_input_format, type: Mongoid::StringifiedSymbol, default: :csv, class_attribute: true, user_editable: true
           field :tabular_input_options, type: Hash, class_attribute: true
 
           # tabular_input_mode: [:line | :array | :hash]
@@ -22,7 +22,7 @@ module RocketJob
           #   :hash
           #     Parses each line from the file into a Hash and uploads each hash for processing by workers.
           #   See IOStreams#each.
-          field :tabular_input_mode, type: Symbol, default: :line, class_attribute: true, user_editable: true, copy_on_restart: true
+          field :tabular_input_mode, type: Mongoid::StringifiedSymbol, default: :line, class_attribute: true, user_editable: true, copy_on_restart: true
 
           validates_inclusion_of :tabular_input_format, in: IOStreams::Tabular.registered_formats
           validates_inclusion_of :tabular_input_mode, in: %i[line array hash row record]
@@ -119,7 +119,9 @@ module RocketJob
         end
 
         def tabular_input_header_present
-          if tabular_input_header.present? || !tabular_input.header? || (tabular_input_mode == :hash || tabular_input_mode == :record)
+          if tabular_input_header.present? ||
+             !tabular_input.header? ||
+             (tabular_input_mode == :hash || tabular_input_mode == :record)
             return
           end
 

data/lib/rocket_job/batch/tabular/output.rb

@@ -10,8 +10,10 @@ module RocketJob
         extend ActiveSupport::Concern
 
         included do
+          warn "#{name} is using RocketJob::Batch::Tabular::Output which is deprecated"
+
           field :tabular_output_header, type: Array, class_attribute: true, user_editable: true, copy_on_restart: true
-          field :tabular_output_format, type: Symbol, default: :csv, class_attribute: true, user_editable: true, copy_on_restart: true
+          field :tabular_output_format, type: Mongoid::StringifiedSymbol, default: :csv, class_attribute: true, user_editable: true, copy_on_restart: true
           field :tabular_output_options, type: Hash, class_attribute: true
 
           validates_inclusion_of :tabular_output_format, in: IOStreams::Tabular.registered_formats
@@ -55,7 +57,7 @@ module RocketJob
 
         # Render the output from the perform.
         def tabular_output_render
-          return unless collect_output?
+          return unless output_categories.present?
 
           @rocket_job_output = tabular_output.render(@rocket_job_output)
         end

data/lib/rocket_job/batch/throttle_running_workers.rb

@@ -37,34 +37,25 @@ module RocketJob
         validates :throttle_running_workers, numericality: {greater_than_or_equal_to: 0}, allow_nil: true
 
         define_batch_throttle :throttle_running_workers_exceeded?, filter: :throttle_filter_id
-
-        # Deprecated. For backward compatibility.
-        alias_method :throttle_running_slices, :throttle_running_workers
-        alias_method :throttle_running_slices=, :throttle_running_workers=
       end
 
       private
 
-      # Returns [Boolean] whether the throttle for this job has been exceeded
+      # Returns [true|false] whether the throttle for this job has been exceeded
       def throttle_running_workers_exceeded?(slice)
-        return unless throttle_running_workers&.positive?
+        return false unless throttle_running_workers&.positive?
 
         input.running.with(read: {mode: :primary}) do |conn|
           conn.where(:id.ne => slice.id).count >= throttle_running_workers
         end
       end
 
-      # Returns [Boolean] whether the throttle for this job has been exceeded
-      #
-      # With a Batch job, allow a higher priority queued job to replace a running one with
-      # a lower priority.
-      def throttle_running_jobs_exceeded?
-        return unless throttle_running_jobs&.positive?
-
-        # Cannot use this class since it will include instances of parent job classes.
-        RocketJob::Job.with(read: {mode: :primary}) do |conn|
-          conn.running.where("_type" => self.class.name, :id.ne => id, :priority.lte => priority).count >= throttle_running_jobs
-        end
+      # Allows another job with a higher priority to start even though this one is running already
+      # @overrides RocketJob::Plugins::Job::ThrottleRunningJobs#throttle_running_jobs_base_query
+      def throttle_running_jobs_base_query
+        query                = super
+        query[:priority.lte] = priority if throttle_running_workers&.positive?
+        query
       end
     end
   end

data/lib/rocket_job/batch/worker.rb

@@ -23,9 +23,6 @@ module RocketJob
       #
       # Slices are destroyed after their records are successfully processed
       #
-      # Results are stored in the output collection if `collect_output?`
-      # `nil` results from workers are kept if `collect_nil_output`
-      #
       # If an exception was thrown the entire slice of records is marked as failed.
       #
       # Thread-safe, can be called by multiple threads at the same time
@@ -40,7 +37,8 @@ module RocketJob
 
         SemanticLogger.named_tagged(job: id.to_s) do
           until worker.shutdown?
-            if slice = input.next_slice(worker.name)
+            slice = input.next_slice(worker.name)
+            if slice
               # Grab a slice before checking the throttle to reduce concurrency race condition.
               return true if slice.fail_on_exception!(re_raise_exceptions) { rocket_job_batch_throttled?(slice, worker) }
               next if slice.failed?
@@ -97,8 +95,8 @@ module RocketJob
         servers = []
         case sub_state
         when :before, :after
-          unless server_name && !worker_on_server?(server_name)
-            servers << ActiveWorker.new(worker_name, started_at, self) if running?
+          if running? && (server_name.nil? || worker_on_server?(server_name))
+            servers << ActiveWorker.new(worker_name, started_at, self)
           end
         when :processing
           query = input.running
@@ -143,19 +141,23 @@ module RocketJob
 
       # Perform individual slice without callbacks
       def rocket_job_perform_slice(slice, &block)
-        count = 0
-        RocketJob::Sliced::Writer::Output.collect(self, slice) do |writer|
-          records = slice.records
-
-          # Skip records already processed, if any.
-          # slice.processing_record_number ||= 0
-          # TODO: Must append to existing output slices before this can be enabled.
-          # if !collect_output && (slice.processing_record_number > 1)
-          #   records = records[slice.processing_record_number - 1..-1]
-          # end
-          # Until the changes above have been implemented, reprocess all records in the slice.
+        slice.processing_record_number ||= 0
+        records                        = []
+        append                         = false
+
+        # Skip processed records in this slice if it has no output categpries.
+        if slice.processing_record_number > 1
+          records = slice.records[slice.processing_record_number - 1..-1]
+          append  = true
+          logger.info("Resuming previously incomplete slice from record number #{slice.processing_record_number}")
+        else
+          # Reprocess all records in this slice.
           slice.processing_record_number = 0
+          records                        = slice.records
+        end
 
+        count = 0
+        RocketJob::Sliced::Writer::Output.collect(self, input_slice: slice, append: append) do |writer|
           records.each do |record|
             slice.processing_record_number += 1
             SemanticLogger.named_tagged(record: slice.current_record_number) do
@@ -174,8 +176,8 @@ module RocketJob
         return block_given? ? yield(record) : perform(record) if _perform_callbacks.empty?
 
         # @rocket_job_input and @rocket_job_output can be modified by before/around callbacks
-        @rocket_job_input         = record
-        @rocket_job_output        = nil
+        @rocket_job_input  = record
+        @rocket_job_output = nil
 
         run_callbacks(:perform) do
           @rocket_job_output =
@@ -186,9 +188,9 @@ module RocketJob
             end
         end
 
-        @rocket_job_input         = nil
-        result                    = @rocket_job_output
-        @rocket_job_output        = nil
+        @rocket_job_input  = nil
+        result             = @rocket_job_output
+        @rocket_job_output = nil
         result
       end
 
@@ -305,11 +307,12 @@ module RocketJob
       # Run Batch before and after callbacks
       def rocket_job_batch_callbacks(worker)
         # If this is the first worker to pickup this job
-        if sub_state == :before
+        case sub_state
+        when :before
           rocket_job_batch_run_before_callbacks
           # Check for 0 record jobs
           rocket_job_batch_complete?(worker.name) if running?
-        elsif sub_state == :after
+        when sub_state == :after
           rocket_job_batch_run_after_callbacks
         end
       end

data/lib/rocket_job/category/base.rb

@@ -0,0 +1,78 @@
+require "active_support/concern"
+
+module RocketJob
+  module Category
+    # Define the layout for each category of input or output data
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        field :name, type: ::Mongoid::StringifiedSymbol, default: :main
+
+        # Whether to compress, encrypt, or use the bzip2 serialization for data in this category.
+        field :serializer, type: ::Mongoid::StringifiedSymbol, default: :compress
+        validates_inclusion_of :serializer, in: %i[none compress encrypt bzip2]
+
+        # The header columns when the file does not include a header row.
+        # Note:
+        # - All column names must be strings so that it can be serialized into MongoDB.
+        field :columns, type: Array
+
+        # On an input collection `format` specifies the format of the input data so that it can be
+        # transformed into a Hash when passed into the `#perform` method.
+        #
+        # On an output collection `format` specifies the format to transform the output hash into.
+        #
+        # `:auto` it uses the `file_name` on this category to determine the format.
+        # `nil` no transformation is performed on the data returned by the `#perform` method.
+        # Any other format supported by IOStreams, for example: csv, :hash, :array, :json, :psv, :fixed
+        #
+        # Default: `nil`
+        field :format, type: ::Mongoid::StringifiedSymbol
+        validates_inclusion_of :format, in: [nil, :auto] + IOStreams::Tabular.registered_formats
+
+        # Any specialized format specific options. For example, `:fixed` format requires a `:layout`.
+        field :format_options, type: Hash
+
+        # When `:format` is not supplied the file name can be used to infer the required format.
+        # Optional.
+        # Default: nil
+        field :file_name, type: IOStreams::Path
+      end
+
+      # Return which slice serializer class to use that matches the current options.
+      def serializer_class
+        case serializer
+        when :none
+          Sliced::Slice
+        when :compress
+          Sliced::CompressedSlice
+        when :encrypt
+          Sliced::EncryptedSlice
+        when :bzip2
+          Sliced::BZip2OutputSlice
+        else
+          raise(ArgumentError, "serialize: #{serializer.inspect} must be :none, :compress, :encrypt, or :bzip2")
+        end
+      end
+
+      def tabular
+        @tabular ||= IOStreams::Tabular.new(
+          columns:        columns,
+          format:         format == :auto ? nil : format,
+          format_options: format_options&.deep_symbolize_keys,
+          file_name:      file_name
+        )
+      end
+
+      def reset_tabular
+        @tabular = nil
+      end
+
+      # Returns [true|false] whether this category has the attributes defined for tabular to work.
+      def tabular?
+        format.present?
+      end
+    end
+  end
+end

data/lib/rocket_job/category/input.rb

@@ -0,0 +1,110 @@
+module RocketJob
+  module Category
+    # Define the layout for each category of input or output data
+    class Input
+      include SemanticLogger::Loggable
+      include Plugins::Document
+      include Category::Base
+
+      embedded_in :job, class_name: "RocketJob::Job", inverse_of: :input_categories
+
+      # Slice size for this input collection
+      field :slice_size, type: Integer, default: 100
+
+      #
+      # The fields below only apply if the field `format` has been set:
+      #
+
+      # List of columns to allow.
+      # Default: nil ( Allow all columns )
+      # Note:
+      #   When supplied any columns that are rejected will be returned in the cleansed columns
+      #   as nil so that they can be ignored during processing.
+      field :allowed_columns, type: Array
+
+      # List of columns that must be present, otherwise an Exception is raised.
+      field :required_columns, type: Array
+
+      # Whether to skip unknown columns in the uploaded file.
+      # Ignores any column that was not found in the `allowed_columns` list.
+      #
+      # false:
+      #   Raises IOStreams::Tabular::InvalidHeader when a column is supplied that is not in `allowed_columns`.
+      # true:
+      #   Ignore additional columns in a file that are not listed in `allowed_columns`
+      #   Job processing will skip the additional columns entirely as if they were not supplied at all.
+      #   A warning is logged with the names of the columns that were ignored.
+      #   The `columns` field will list all skipped columns with a nil value so that downstream workers
+      #   know to ignore those columns.
+      #
+      # Notes:
+      # - Only applicable when `allowed_columns` has been set.
+      # - Recommended to leave as `false` otherwise a misspelled column can result in missed columns.
+      field :skip_unknown, type: ::Mongoid::Boolean, default: false
+      validates_inclusion_of :skip_unknown, in: [true, false]
+
+      # When `#upload` is called with a file_name, it uploads the file using any of the following approaches:
+      # :line
+      #   Uploads the file a line (String) at a time for processing by workers.
+      #   This is the default behavior and is the most performant since it leaves the parsing of each line
+      #   up to the workers themselves.
+      # :array
+      #   Parses each line from the file as an Array and uploads each array for processing by workers.
+      #   Every line in the input file is parsed and converted into an array before uploading.
+      #   This approach ensures that the entire files is valid before starting to process it.
+      #   Ideal for when files may contain invalid lines.
+      #   Not recommended for large files since the CSV or other parsing is performed sequentially during the
+      #   upload process.
+      # :hash
+      #   Parses each line from the file into a Hash and uploads each hash for processing by workers.
+      #   Similar to :array above in that the entire file is parsed before processing is started.
+      #   Slightly less efficient than :array since it stores every record as a hash with both the key and value.
+      #
+      # Recommend using :array when the entire file must be parsed/validated before processing is started, and
+      # upload time is not important.
+      # See IOStreams#each for more details.
+      field :mode, type: ::Mongoid::StringifiedSymbol, default: :line
+      validates_inclusion_of :mode, in: %i[line array hash]
+
+      # When reading tabular input data (e.g. CSV, PSV) the header is automatically cleansed.
+      # This removes issues when the input header varies in case and other small ways. See IOStreams::Tabular
+      # Currently Supported:
+      #   :default
+      #     Each column is cleansed as follows:
+      #     - Leading and trailing whitespace is stripped.
+      #     - All characters converted to lower case.
+      #     - Spaces and '-' are converted to '_'.
+      #     - All characters except for letters, digits, and '_' are stripped.
+      #   :none
+      #     Do not cleanse the columns names supplied in the header row.
+      #
+      # Note: Submit a ticket if you have other cleansers that you want added.
+      field :header_cleanser, type: ::Mongoid::StringifiedSymbol, default: :default
+      validates :header_cleanser, inclusion: %i[default none]
+
+      validates_presence_of :slice_size
+
+      # Cleanses the header column names when `cleanse_header` is true
+      def cleanse_header!
+        return unless header_cleanser == :default
+
+        ignored_columns = tabular.header.cleanse!
+        logger.warn("Stripped out invalid columns from custom header", ignored_columns) unless ignored_columns.empty?
+
+        self.columns = tabular.header.columns
+      end
+
+      def tabular
+        @tabular ||= IOStreams::Tabular.new(
+          columns:          columns,
+          format:           format == :auto ? nil : format,
+          format_options:   format_options&.deep_symbolize_keys,
+          file_name:        file_name,
+          allowed_columns:  allowed_columns,
+          required_columns: required_columns,
+          skip_unknown:     skip_unknown
+        )
+      end
+    end
+  end
+end