rocketjob 6.3.2 → 7.1.0

data/lib/rocket_job/category/input.rb

@@ -21,9 +21,13 @@ module RocketJob
       # 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.
+      #
+      # Deprecated, use `schema`, whose `fieldsMatch` says which columns a file can have.
       field :allowed_columns, type: Array
 
       # List of columns that must be present, otherwise an Exception is raised.
+      #
+      # Deprecated, use `schema`, with `constraints: {required: true}` on each field that a file must have.
       field :required_columns, type: Array
 
       # Whether to skip unknown columns in the uploaded file.
@@ -41,29 +45,26 @@ module RocketJob
       # Notes:
       # - Only applicable when `allowed_columns` has been set.
       # - Recommended to leave as `false` otherwise a misspelled column can result in missed columns.
+      # - Deprecated, use `schema`, whose `fieldsMatch` of "subset" or "partial" skips the other 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:
+      # How `#upload` reads a file into a category with a schema, see #schema, unless the upload is given a
+      # `stream_mode:`:
       # :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.
+      #   Uploads the lines of the file, which the workers parse by the schema, so that each value reaches `#perform` as
+      #   its type, such as a Date. This is the default, and the most performant, since the workers parse the lines.
       # :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.
+      #   Also parses every line by the schema when it is uploaded, so that a file with a value that is not valid is not
+      #   uploaded at all. The lines are uploaded, as in :line mode. Not recommended for large files, since the lines
+      #   are parsed one after the other during the upload.
+      # :array
+      #   Cannot be used with a schema.
       #
-      # 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.
+      # Without a schema the mode does not change how a file is uploaded: its lines are uploaded, unless the upload is
+      # given `stream_mode: :array` or `stream_mode: :hash`, which parses each line into an Array or a Hash first, see
+      # RocketJob::Batch::IO#upload. A category with a format whose files have a header row, such as CSV, cannot be
+      # uploaded with `stream_mode: :hash` without a schema.
       field :mode, type: ::Mongoid::StringifiedSymbol, default: :line
       validates_inclusion_of :mode, in: %i[line array hash]
 
@@ -80,11 +81,27 @@ module RocketJob
       #     Do not cleanse the columns names supplied in the header row.
       #
       # Note: Submit a ticket if you have other cleansers that you want added.
+      #
+      # Deprecated, use `schema`, whose fields name the keys of each record, and which the columns of the header row
+      # are matched to whatever their case, spaces and punctuation.
       field :header_cleanser, type: ::Mongoid::StringifiedSymbol, default: :default
       validates :header_cleanser, inclusion: %i[default none]
 
       validates_inclusion_of :serializer, in: %i[none compress encrypt]
 
+      # Returns [Array<String>] the names of the deprecated options in the supplied properties of an input category,
+      # with String keys, see Category::Base.deprecated_column_options: `allowed_columns`, `required_columns`,
+      # `skip_unknown` when true, `header_cleanser` when :none, and `columns` without a schema, since with one they
+      # hold the header row read from the file.
+      def self.deprecated_column_options(properties)
+        names = []
+        names << "columns" if properties["columns"].present? && properties["schema"].blank?
+        names.concat(%w[allowed_columns required_columns].select { |name| properties[name].present? })
+        names << "skip_unknown" if [true, "true"].include?(properties["skip_unknown"])
+        names << "header_cleanser" if properties["header_cleanser"].to_s == "none"
+        names
+      end
+
       # Cleanses the header column names when `cleanse_header` is true
       def cleanse_header!
         return unless header_cleanser == :default
@@ -96,6 +113,8 @@ module RocketJob
       end
 
       def tabular
+        return @tabular ||= schema_tabular if schema.present?
+
         @tabular ||= IOStreams::Tabular.new(
           columns:          columns,
           format:           format == :auto ? nil : format,
@@ -133,36 +152,143 @@ module RocketJob
           @tabular = nil
         end
 
-        # Remove non-printable characters from tabular input formats.
-        if tabular?
+        if schema.present?
+          # IOStreams reads the text of a file with a schema as UTF-8, and raises for text that is not valid UTF-8,
+          # unless an encoding is set on the supplied path, which reads it instead. A schema set on the supplied path
+          # is kept.
+          path.schema(schema) if path.schema.nil?
+        elsif tabular?
+          # Remove non-printable characters from tabular input formats.
           # Cannot change the length of fixed width lines.
           replace = format == :fixed ? " " : ""
-          path.option_or_stream(:encode, encoding: "UTF-8", cleaner: :printable, replace: replace)
+          path.encoding("UTF-8", cleaner: :printable, replace: replace)
         end
         path
       end
 
-      # Return a lambda to extract the header row from the uploaded file.
+      # Yields each record read from the supplied path for an upload, see RocketJob::Batch::IO#upload, in the supplied
+      # mode, otherwise in :line mode, see `IOStreams::Stream#each`.
+      #
+      # With a schema it yields the lines of the file in the supplied mode, otherwise in this category's mode, see
+      # #mode, and in :hash mode parses each line after the header row by the schema first, so that a value that is not
+      # valid raises before any record is processed.
+      def each_record(path, mode: nil, **args, &)
+        return path.each(mode || :line, **args, &) if schema.blank?
+
+        mode ||= self.mode
+        if mode == :array
+          raise(ArgumentError,
+                "Input category #{name} has a schema, which cannot be uploaded in :array mode, use :line or :hash")
+        end
+        return path.each(:line, **args, &) if mode == :line
+
+        path.each(:line, **args) do |line|
+          # The lines before the header row, and the header row itself, are read by #extract_header_callback.
+          tabular.record_parse(line) unless tabular.header?
+          yield(line)
+        end
+      end
+
+      # Returns the lambda that the upload calls with each record before the first that it stores, instead of storing
+      # it, until the lambda returns true, see `Sliced::Writer::Input`: it reads the header row, when the file has one,
+      # then calls the supplied `on_first` with it. Otherwise it calls `on_first` with the first record. Returns nil
+      # when there is neither.
+      #
+      # A blank line before the header row is skipped, as IOStreams skips it when it reads the header row itself, such
+      # as in :hash mode, so that the header row is not stored as a record.
+      #
+      # The header row is a line, or an Array when the upload parses each line with `stream_mode: :array`, which the
+      # format returns as it is.
       def extract_header_callback(on_first)
-        return on_first unless tabular? && tabular.header?
-
-        case mode
-        when :line
-          lambda do |line|
-            tabular.parse_header(line)
-            cleanse_header!
-            self.columns = tabular.header.columns
-            # Call chained on_first if present
-            on_first&.call(line)
-          end
-        when :array
-          lambda do |row|
-            tabular.header.columns = row
-            cleanse_header!
-            self.columns = category.tabular.header.columns
-            # Call chained on_first if present
-            on_first&.call(line)
-          end
+        return schema_header_callback(on_first) if schema.present?
+        return first_record_callback(on_first) unless tabular? && tabular.header?
+
+        lambda do |line|
+          next false if line.blank?
+
+          tabular.parse_header(line)
+          cleanse_header!
+          self.columns = tabular.header.columns
+          warn_repeated_columns
+          # Call chained on_first if present
+          on_first&.call(line)
+          true
+        end
+      end
+
+      private
+
+      # Reports a deprecation warning, see RocketJob::Deprecation, at the line of the application that uploads a file
+      # whose header row has columns that are the same key once cleansed, such as `a` and `A`, since each record holds
+      # the value of only the last of them, and IOStreams 3.0, which Rocket Job 8 requires, raises for them.
+      def warn_repeated_columns
+        repeated = columns.compact.tally.select { |_column, count| count > 1 }.keys
+        return if repeated.empty?
+
+        RocketJob::Deprecation.warn(
+          "a header row whose columns are the same key, #{repeated.collect(&:inspect).join(', ')}, is deprecated, " \
+          "since each record holds the value of only the last of them, and Rocket Job 8 raises: rename the " \
+          "columns of the file, or describe them with the schema: of the input category, see " \
+          "#{RocketJob::Deprecation::UPGRADE_GUIDE}"
+        )
+      end
+
+      # Returns [IOStreams::Tabular] that reads the records of this category by its schema, see Category::Base#schema,
+      # and has read the header row that an upload read from the file, see #columns, so that the workers parse each line
+      # by it.
+      def schema_tabular
+        tabular = super
+        tabular.read_header(columns) if columns.present? && tabular.header?
+        tabular
+      end
+
+      # Returns the lambda that reads the header row of a file with a schema, see #extract_header_callback. Its columns
+      # are matched to the fields of the schema, which raises IOStreams::Errors::InvalidHeader when they do not match,
+      # and are kept as they are in the file, see #columns. A blank row before it, which IOStreams does not read as a
+      # header row, such as a line of only commas, is skipped, as IOStreams skips it when it reads the header row itself.
+      #
+      # With a schema, `columns` hold the header row of the file uploaded, so an upload reads the header row of its own
+      # file, rather than keep the columns of an earlier one, such as those that a job scheduled again copies from its
+      # last run, see Plugins::Cron.
+      def schema_header_callback(on_first)
+        self.columns = nil
+        @tabular     = nil
+        return first_record_callback(on_first) unless tabular.header?
+
+        lambda do |line|
+          tabular.read_header(line)
+          next false if tabular.header?
+
+          self.columns = tabular.header.columns
+          # Call chained on_first if present
+          on_first&.call(line)
+          true
+        end
+      end
+
+      # The schema describes the columns of the file, so the options that describe them without one cannot be set with
+      # it, see Category::Base#schema.
+      def fields_replaced_by_schema
+        replaced = super + %i[allowed_columns required_columns].select { |name| public_send(name).present? }
+        replaced << :skip_unknown if skip_unknown
+        replaced << :header_cleanser if header_cleanser == :none
+        replaced
+      end
+
+      # The :array mode cannot be used with a schema, see #mode.
+      def schema_replaces_fields
+        super
+        errors.add(:mode, "cannot be :array with a schema, use :line or :hash") if schema.present? && mode == :array
+      end
+
+      # Returns the lambda that calls the supplied `on_first` with the first record uploaded, which is not stored, see
+      # #extract_header_callback, or nil without one.
+      def first_record_callback(on_first)
+        return unless on_first
+
+        lambda do |record|
+          on_first.call(record)
+          true
         end
       end
     end

data/lib/rocket_job/category/output.rb

@@ -29,6 +29,13 @@ module RocketJob
           slice_class:     serializer_class
         )
       end
+
+      private
+
+      # The schema gives the columns of the file written, see Category::Base#schema.
+      def fields_replaced_by_schema
+        columns.present? ? super + [:columns] : super
+      end
     end
   end
 end

data/lib/rocket_job/config.rb

@@ -81,6 +81,11 @@ module RocketJob
       logger.debug "Reading Mongo configuration from: #{config_file}"
       ::Mongoid.load!(config_file, environment)
 
+      # Mongoid 9 requires `Time.zone` to be set in order to mongoize Date and
+      # Time values. When running outside of Rails it may be unset, so default
+      # it here without overriding an explicit application setting.
+      ::Time.zone_default ||= ::ActiveSupport::TimeZone["UTC"]
+
       config_file =
         if encryption_file_name
           Pathname.new(encryption_file_name)
@@ -100,7 +105,7 @@ module RocketJob
     def self.filter
       raise(ArgumentError, "Cannot supply both an include_filter and an exclude_filter") if include_filter && exclude_filter
 
-      filter                   = where_filter
+      filter = where_filter
       (filter ||= {})["_type"] = include_filter if include_filter
       (filter ||= {})["_type"] = {"$not" => exclude_filter} if exclude_filter
       filter&.dup

data/lib/rocket_job/deprecation.rb

@@ -0,0 +1,51 @@
+module RocketJob
+  # Reports the use of a deprecated option or method as a Ruby deprecation warning, see `Kernel#warn`, as IOStreams
+  # does, see `IOStreams::Deprecation`:
+  # - Only while deprecation warnings are on, see `Warning[:deprecated]`. They are off by default, so production stays
+  #   quiet, and on in tests run by Minitest or test-unit, or with `ruby -W:deprecated` or `RUBYOPT=-W:deprecated`.
+  # - Written to `$stderr`, unless the application routes them elsewhere, such as to its log, or raises them in its
+  #   tests, by overriding `Warning.warn`.
+  #
+  # Each warning names the first line of the call stack outside Rocket Job, such as the line of a job class that
+  # defines a category with a deprecated option, rather than a line of Rocket Job.
+  module Deprecation
+    # The directory of the files of this library, whose lines are skipped when finding the line that used it.
+    LIB_DIR = "#{File.expand_path('..', __dir__)}/".freeze
+
+    # Where the upgrade guide says what replaces each deprecated option.
+    UPGRADE_GUIDE = "https://rocketjob.reidmorrison.com/upgrading.html#upgrading-to-v71".freeze
+
+    # Reports that the application used something deprecated, unless deprecation warnings are off, with the message,
+    # which says what is deprecated and what to use instead, after "Rocket Job: ", at the first line of the call stack
+    # outside this library and the libraries that call it, or without a line when there is none, such as in a worker
+    # that builds the job of a Dirmon entry.
+    #
+    # Returns nil.
+    def self.warn(message)
+      return unless Warning[:deprecated]
+
+      dirs    = library_dirs
+      uplevel = caller_locations(1).index { |location| !library?(location, dirs) }
+      # Kernel#warn counts its own caller, this method, as level 0.
+      Kernel.warn("Rocket Job: #{message}", uplevel: uplevel && (uplevel + 1), category: :deprecated)
+      nil
+    end
+
+    # Returns [Array<String>] the directories whose lines are skipped when finding the line of the application: this
+    # library, the other gems, which call it back, such as Active Support's callbacks and Mongoid, and Ruby's own
+    # library.
+    def self.library_dirs
+      gems = Gem.loaded_specs.each_value.filter_map { |spec| "#{spec.full_gem_path}/" unless spec.name == "rocketjob" }
+      [LIB_DIR, "#{RbConfig::CONFIG['rubylibdir']}/", *gems]
+    end
+    private_class_method :library_dirs
+
+    # Returns [true|false] whether the line of the call stack is in a file of a library, see .library_dirs, or of Ruby
+    # itself.
+    def self.library?(location, dirs)
+      path = (location.absolute_path || location.path).to_s
+      path.start_with?("<internal:") || dirs.any? { |dir| path.start_with?(dir) }
+    end
+    private_class_method :library?
+  end
+end

data/lib/rocket_job/dirmon_entry.rb

@@ -286,14 +286,16 @@ module RocketJob
       klass = job_class
       return unless klass
 
-      properties.each_pair do |k, _v|
-        next if klass.public_method_defined?("#{k}=".to_sym)
+      # Mongoid 9 returns Hash field keys as Strings, earlier versions as Symbols.
+      properties.each_pair do |raw_key, value|
+        k = raw_key.to_sym
+        next if klass.public_method_defined?(:"#{k}=")
 
         if %i[output_categories input_categories].include?(k)
           category_class = k == :input_categories ? RocketJob::Category::Input : RocketJob::Category::Output
-          properties[k].each do |category|
+          value.each do |category|
             category.each_pair do |key, _value|
-              next if category_class.public_method_defined?("#{key}=".to_sym)
+              next if category_class.public_method_defined?(:"#{key}=")
 
               errors.add(
                 :properties,

data/lib/rocket_job/event.rb

@@ -12,6 +12,11 @@ module RocketJob
 
     ALL_EVENTS = "*".freeze
 
+    # MongoDB OperationFailure codes that are safe to ignore when concurrently
+    # creating the polling collection and its TTL index:
+    #   48 NamespaceExists, 85 IndexOptionsConflict, 86 IndexKeySpecsConflict.
+    IGNORABLE_CREATE_CODES = [48, 85, 86].freeze
+
     # Capped collection long polling interval.
     class_attribute :long_poll_seconds, instance_accessor: false
     self.long_poll_seconds = 300
@@ -23,6 +28,28 @@ module RocketJob
     class_attribute :capped_collection_size, instance_accessor: false
     self.capped_collection_size = 128 * 1024 * 1024
 
+    # Event listener strategy:
+    #   :capped  - Tail a capped collection with a tailable cursor (default).
+    #              Lowest latency, but requires a data store that supports capped
+    #              collections and tailable cursors (i.e. a real MongoDB server).
+    #   :polling - Poll a regular collection for new events. Slightly higher latency
+    #              (bounded by `poll_interval`), but works on any MongoDB-compatible
+    #              store, including AWS DocumentDB which has no capped collections.
+    class_attribute :listener_strategy, instance_accessor: false
+    self.listener_strategy = :capped
+
+    # Polling strategy: seconds to wait between polls for new events.
+    class_attribute :poll_interval, instance_accessor: false
+    self.poll_interval = 1
+
+    # Polling strategy: seconds an event is retained before a TTL index removes it.
+    # Must comfortably exceed the longest expected listener downtime so that a
+    # restarting server can still recover events published while it was away.
+    #
+    # Default: 1 hour.
+    class_attribute :event_retention_seconds, instance_accessor: false
+    self.event_retention_seconds = 60 * 60
+
     # Mandatory Event Name
     #   Examples:
     #     '/rocket_job/config'
@@ -81,14 +108,23 @@ module RocketJob
       @subscribers.each_value { |v| v.delete_if { |i| i.object_id == handle } }
     end
 
-    # Indefinitely tail the capped collection looking for new events.
+    # Indefinitely watch for new events, dispatching each to its subscribers.
     #   time: the start time from which to start looking for new events.
     def self.listener(time: @load_time)
       Thread.current.name = "rocketjob event"
-      create_capped_collection
 
-      logger.info("Event listener started")
-      tail_capped_collection(time) { |event| process_event(event) }
+      case listener_strategy
+      when :capped
+        create_capped_collection
+        logger.info("Event listener started (capped collection)")
+        tail_capped_collection(time) { |event| process_event(event) }
+      when :polling
+        create_polling_collection
+        logger.info("Event listener started (polling, interval: #{poll_interval}s)")
+        poll_collection(time) { |event| process_event(event) }
+      else
+        raise(ArgumentError, "Unknown RocketJob::Event.listener_strategy: #{listener_strategy.inspect}")
+      end
     rescue Exception => e
       logger.error("#listener Event listener is terminating due to unhandled exception", e)
       raise(e)
@@ -134,6 +170,50 @@ module RocketJob
       retry
     end
 
+    # Create the regular (non-capped) collection used by the polling strategy,
+    # along with a TTL index that expires old events.
+    #
+    # Safe to call repeatedly: it never drops data, and tolerates the collection
+    # and index already existing.
+    def self.create_polling_collection
+      collection.client[collection_name].create unless collection_exists?
+      collection.indexes.create_one({created_at: 1}, expire_after: event_retention_seconds)
+    rescue Mongo::Error::OperationFailure => e
+      # Ignore "collection already exists" and "index already exists" races between
+      # multiple servers starting at once. Anything else is a real error.
+      raise(e) unless IGNORABLE_CREATE_CODES.include?(e.code)
+    end
+
+    # Indefinitely poll a regular collection for new events.
+    #   time: the start time from which to start looking for new events.
+    #
+    # After the first poll the `_id` of the last event seen is used as the
+    # watermark, which is monotonic and unique, so events sharing a `created_at`
+    # timestamp are never skipped.
+    def self.poll_collection(time, &block)
+      last_id = nil
+      loop do
+        last_id = poll_once(time, last_id, &block)
+        sleep(poll_interval)
+      end
+    rescue Mongo::Error::SocketError, Mongo::Error::SocketTimeoutError, Mongo::Error::OperationFailure, Timeout::Error => e
+      logger.info("Polling failed, retrying: #{e.class.name} #{e.message}")
+      sleep(poll_interval)
+      retry
+    end
+
+    # Perform a single polling pass, yielding every event newer than the watermark
+    # and returning the new watermark (the `_id` of the last event seen, or the
+    # supplied `last_id` when no new events were found).
+    def self.poll_once(time, last_id = nil)
+      filter = last_id ? {_id: {"$gt" => last_id}} : {created_at: {"$gt" => time}}
+      collection.find(filter).sort(_id: 1).each do |doc|
+        last_id = doc["_id"]
+        yield(Mongoid::Factory.from_db(Event, doc))
+      end
+      last_id
+    end
+
     # Process a new event, calling registered subscribers.
     def self.process_event(event)
       logger.info("Event Received", event.attributes)

data/lib/rocket_job/extensions/mongo/logging.rb

@@ -4,6 +4,7 @@ module Mongo
   class Monitoring
     class CommandLogSubscriber
       include SemanticLogger::Loggable
+
       logger.name = "Mongo"
 
       undef :started

data/lib/rocket_job/extensions/mongoid/clients/options.rb

@@ -11,7 +11,7 @@ module RocketJob
       end
 
       def collection(parent = nil)
-        @collection_name ? mongo_client[@collection_name] : super(parent)
+        @collection_name ? mongo_client[@collection_name] : super
       end
 
       def collection_name
@@ -31,5 +31,5 @@ module RocketJob
   end
 end
 
-::Mongoid::Criteria.include(RocketJob::MongoidClients::Options)
-::Mongoid::Document.include(RocketJob::MongoidClients::Options)
+Mongoid::Criteria.include(RocketJob::MongoidClients::Options)
+Mongoid::Document.include(RocketJob::MongoidClients::Options)

data/lib/rocket_job/extensions/mongoid/contextual/mongo.rb

@@ -1,15 +1,14 @@
-::Mongoid::Contextual::Mongo
 module Mongoid
   module Contextual
     class Mongo
       def initialize(criteria)
         @criteria = criteria
         @klass    = criteria.klass
-        @cache    = criteria.options[:cache]
-        # Only line changed is here, get collection name from criteria, not @klass
+        # Only line changed from the Mongoid implementation is here: fetch the
+        # collection from the criteria so a custom collection_name is honored
+        # rather than always using @klass.collection.
         # @collection = @klass.collection
         @collection = criteria.collection
-
         criteria.send(:merge_type_selection)
         @view = collection.find(criteria.selector, session: _session)
         apply_options

data/lib/rocket_job/extensions/mongoid/factory.rb

@@ -4,11 +4,11 @@ module RocketJob
   # Don't convert to Mongoid::Factory since it conflicts with Mongoid use.
   module MongoidFactory
     def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
-      obj                 = super(klass, attributes, criteria, selected_fields)
+      obj                 = super
       obj.collection_name = criteria.collection_name if criteria
       obj
     end
   end
 end
 
-::Mongoid::Factory.extend(RocketJob::MongoidFactory)
+Mongoid::Factory.extend(RocketJob::MongoidFactory)

data/lib/rocket_job/extensions/psych/yaml_tree.rb

@@ -1,8 +1,12 @@
 require "psych/visitors/yaml_tree"
 
-class Psych::Visitors::YAMLTree
-  # Serialize IOStream path as a string
-  def visit_IOStreams_Path(o)
-    visit_String(o.to_s)
+module Psych
+  module Visitors
+    class YAMLTree
+      # Serialize IOStream path as a string
+      def visit_IOStreams_Path(o)
+        visit_String(o.to_s)
+      end
+    end
   end
 end

data/lib/rocket_job/extensions/rocket_job_adapter.rb

@@ -4,7 +4,7 @@ module ActiveJob
     #
     # Ruby's missing batch system.
     #
-    # Read more about Rocket Job {here}[http://rocketjob.io].
+    # Read more about Rocket Job {here}[https://rocketjob.reidmorrison.com].
     #
     # To use Rocket Job set the queue_adapter config to +:rocket_job+.
     #

data/lib/rocket_job/jobs/active_job.rb

@@ -1,7 +1,7 @@
 module RocketJob
   module Jobs
     # Used to wrap an Active Job
-    class ActiveJob < RocketJob::Job #:nodoc:
+    class ActiveJob < RocketJob::Job # :nodoc:
       field :data, type: Hash
       field :active_job_id, type: String
       field :active_job_class, type: String

data/lib/rocket_job/jobs/copy_file_job.rb

@@ -82,8 +82,18 @@ module RocketJob
         self.description ||= "Copying to #{target_url}"
       end
 
+      # Applies the supplied streams to the path, in order. The `none` stream, which `source_streams` and
+      # `target_streams` default to, removes the streams before it, so that on its own the file is read or written as
+      # it is stored, see `IOStreams::Stream#raw`, rather than with IOStreams' deprecated `stream(:none)`.
       def apply_streams(path, streams)
-        streams.each_pair do |stream, args|
+        streams = streams.to_a
+        none    = streams.rindex { |stream, _args| stream.to_s == "none" }
+        if none
+          streams = streams.drop(none + 1)
+          return path.raw if streams.empty?
+        end
+
+        streams.each do |stream, args|
           stream_args = args.nil? ? {} : decode_args(args)
           path.stream(stream.to_sym, **stream_args)
         end

data/lib/rocket_job/jobs/dirmon_job.rb

@@ -85,7 +85,9 @@ module RocketJob
           file_names[key] = size if size
         end
       rescue StandardError => e
-        logger.error("Dirmon Entry: #{dirmon_entry.id} failed. Moved to `failed` state to prevent processing again without manual intervention.", e)
+        logger.error(
+          "Dirmon Entry: #{dirmon_entry.id} failed. Moved to `failed` state to prevent processing again without manual intervention.", e
+        )
         dirmon_entry.fail(worker_name, e)
         dirmon_entry.save(validate: false)
       end

data/lib/rocket_job/jobs/on_demand_batch_job.rb

@@ -105,7 +105,7 @@ module RocketJob
 
       # Add a new output category and collect output for it.
       def add_output_category(**args)
-        self.output_categories << RocketJob::Category::Output.new(**args)
+        output_categories << RocketJob::Category::Output.new(**args)
       end
 
       private