restforce-db 3.5.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a09f48ae39e990498c4277c8c538ddefa6299c64
-  data.tar.gz: f908032e59d2f1fc53177e396e6d3166f5643b6d
+  metadata.gz: c63f46aaa750d8936499c83d7e6f135e962c9d2e
+  data.tar.gz: 2838e8434cef8bb652fb3aac1251e4ce287f412d
 SHA512:
-  metadata.gz: 7264171810bbe421b589db829948ebf027487958ebdf4d2b29db5ce18842e0bb1c05c16b2d1567522e916f8d85041a892a507e23661f77b4bbb83d5eac66df9c
-  data.tar.gz: 4a19e74fb51bf354a950c9c012995bf3b2b65053d9a7636fe147141587d9b78d2c4be1600db7ab2aaa17e405fdf0b73aabb88eac6518c2613a1ffac77301d654
+  metadata.gz: 0c5ac6edc50ab9ea35777bcfc677385feb7ea00734108b560012d249612e7c2f29dd65663d9390ceff16ec9272126f62014f282630f66d566128e0429cc0441c
+  data.tar.gz: 88c449e199a291dd8ea652d933dd51e0c07ed16e9cba034e297fd1cdeeb7f6aa69f7a9cde5cca5f93ea3125b1ee2b9fc17ab8f1e79d874f46adfc98ca020b139

data/lib/file_daemon.rb

@@ -15,12 +15,21 @@ module FileDaemon
   # :nodoc:
   module ClassMethods
 
+    # Public: Force-reopen all files at their current paths. Allows for rotation
+    # of log files outside of the context of an actual process fork.
+    #
+    # Returns nothing.
+    def reopen_files
+      before_fork
+      after_fork
+    end
+
     # Public: Store the list of currently open file descriptors so that they
     # may be reopened when a new process is spawned.
     #
     # Returns nothing.
     def before_fork
-      @files_to_reopen ||= ObjectSpace.each_object(File).reject(&:closed?)
+      @files_to_reopen = ObjectSpace.each_object(File).reject(&:closed?)
     end
 
     # Public: Reopen all file descriptors that have been stored through the

data/lib/forked_process.rb

@@ -0,0 +1,45 @@
+require "English"
+
+# ForkedProcess exposes a small API for performing a block of code in a
+# forked process, and relaying its output to another block.
+class ForkedProcess
+
+  # Public: Define a callback which will be run in a forked process.
+  #
+  # Yields an IO object opened for writing when `run` is invoked.
+  # Returns nothing.
+  def write(&block)
+    @write_block = block
+  end
+
+  # Public: Define a callback which reads in the output from the forked
+  # process.
+  #
+  # Yields an IO object opened for reading when `run` is invoked.
+  # Returns nothing.
+  def read(&block)
+    @read_block = block
+  end
+
+  # Public: Fork a process, opening a pipe for IO and yielding the write and
+  # read components to the relevant blocks.
+  #
+  # Returns nothing.
+  def run
+    reader, writer = IO.pipe
+
+    pid = fork do
+      reader.close
+      @write_block.call(writer)
+      writer.close
+      exit!(0)
+    end
+
+    writer.close
+    @read_block.call(reader)
+    Process.wait(pid)
+
+    raise "Forked process did not exit successfully" unless $CHILD_STATUS.success?
+  end
+
+end

data/lib/restforce/db/client.rb

@@ -7,6 +7,33 @@ module Restforce
     # not yet supported by the base gem.
     class Client < ::Restforce::Data::Client
 
+      # Public: Instantiate a new Restforce::DB::Client. Updates the middleware
+      # stack to account for some additional instrumentation and automatically
+      # retry timed out requests.
+      def initialize(**_)
+        super
+
+        # NOTE: By default, the Retry middleware will catch timeout exceptions,
+        # and retry up to two times. For more information, see:
+        # https://github.com/lostisland/faraday/blob/master/lib/faraday/request/retry.rb
+        middleware.insert(
+          -2,
+          Faraday::Request::Retry,
+          methods: [:get, :head, :options, :put, :patch, :delete],
+        )
+
+        middleware.insert_after(
+          Restforce::Middleware::InstanceURL,
+          FaradayMiddleware::Instrumentation,
+          name: "request.restforce_db",
+        )
+
+        middleware.insert_before(
+          FaradayMiddleware::Instrumentation,
+          Restforce::DB::Middleware::StoreRequestBody,
+        )
+      end
+
       # Public: Get a list of Salesforce records which have been deleted between
       # the specified times.
       #

data/lib/restforce/db/command.rb

@@ -15,7 +15,6 @@ module Restforce
       # args - A set of command line arguments to pass to the OptionParser.
       def initialize(args)
         @options = {
-          verbose: false,
           pid_dir: Rails.root.join("tmp", "pids"),
           config:  Rails.root.join("config", "restforce-db.yml"),
           tracker: Rails.root.join("config", ".restforce"),
@@ -104,9 +103,6 @@ module Restforce
           opt.on("-t FILE", "--tracker FILE", "The file where run characteristics should be logged.") do |file|
             @options[:tracker] = file
           end
-          opt.on("-v", "--verbose", "Turn on noisy logging.") do
-            @options[:verbose] = true
-          end
         end
       end
 

data/lib/restforce/db/field_processor.rb

@@ -10,19 +10,54 @@ module Restforce
       # specific field.
       RELATIONSHIP_MATCHER = /(.+)__r\./.freeze
 
-      # Internal: Get a global cache with which to store/fetch the writable
-      # fields for each Salesforce SObject Type.
-      #
-      # Returns a Hash.
-      def self.field_cache
-        @field_cache ||= {}
-      end
+      class << self
+
+        # Public: Fetch the field metadata for all Salesforce models registered
+        # through mappings in the system. Useful to ensure that forked worker
+        # processes have access to all of the field metadata without the need
+        # for additional querying.
+        #
+        # Returns nothing.
+        def preload
+          Registry.each { |mapping| fetch(mapping.salesforce_model) }
+        end
+
+        # Public: Get a global cache with which to store/fetch the field
+        # metadata for each Salesforce Object Type.
+        #
+        # Returns a Hash.
+        def field_cache
+          @field_cache ||= {}
+        end
+
+        # Public: Get a collection of all fields for the passed Salesforce
+        # Object Type, with an indication of whether or not they are readable
+        # and writable for both create and update actions.
+        #
+        # sobject_type - A String name of an Object Type in Salesforce.
+        #
+        # Returns a Hash.
+        def fetch(sobject_type)
+          field_cache[sobject_type] ||= begin
+            fields = DB.client.describe(sobject_type).fields
+
+            fields.each_with_object({}) do |field, permissions|
+              permissions[field["name"]] = {
+                read:   true,
+                create: field["createable"],
+                update: field["updateable"],
+              }
+            end
+          end
+        end
+
+        # Public: Clear out the global field cache.
+        #
+        # Returns nothing.
+        def reset
+          @field_cache = {}
+        end
 
-      # Internal: Clear out the global field cache.
-      #
-      # Returns nothing.
-      def self.reset
-        @field_cache = {}
       end
 
       # Public: Get a list of valid fields for a specific action from the passed
@@ -69,7 +104,7 @@ module Restforce
       #
       # Returns a Boolean.
       def available?(sobject_type, field, action)
-        permissions = field_metadata(sobject_type)[field]
+        permissions = self.class.fetch(sobject_type)[field]
         return false unless permissions
 
         permissions[action]
@@ -89,27 +124,6 @@ module Restforce
         field =~ RELATIONSHIP_MATCHER
       end
 
-      # Internal: Get a collection of all fields for the passed Salesforce
-      # SObject Type, with an indication of whether or not they are readable and
-      # writable for both create and update actions.
-      #
-      # sobject_type - A String name of an SObject Type in Salesforce.
-      #
-      # Returns a Hash.
-      def field_metadata(sobject_type)
-        self.class.field_cache[sobject_type] ||= begin
-          fields = Restforce::DB.client.describe(sobject_type).fields
-
-          fields.each_with_object({}) do |field, permissions|
-            permissions[field["name"]] = {
-              read:   true,
-              create: field["createable"],
-              update: field["updateable"],
-            }
-          end
-        end
-      end
-
     end
 
   end

data/lib/restforce/db/loggable.rb

@@ -0,0 +1,43 @@
+module Restforce
+
+  module DB
+
+    # Restforce::DB::Loggable defines shared behaviors for objects which
+    # need access to generic logging functionality.
+    module Loggable
+
+      # Public: Add a `logger` attribute to the object including this module.
+      #
+      # base - The object which is including the `Loggable` module.
+      def self.included(base)
+        base.send :attr_accessor, :logger
+      end
+
+      private
+
+      # Internal: Log the passed text at the specified level.
+      #
+      # text  - The piece of text which should be logged for this worker.
+      # level - The level at which the text should be logged. Defaults to :info.
+      #
+      # Returns nothing.
+      def log(text, level = :info)
+        return unless logger
+        logger.send(level, text)
+      end
+
+      # Internal: Log an error for the worker, outputting the entire error
+      # stacktrace and applying the appropriate log level.
+      #
+      # exception - An Exception object.
+      #
+      # Returns nothing.
+      def error(exception)
+        log exception, :error
+      end
+
+    end
+
+  end
+
+end

data/lib/restforce/db/runner.rb

@@ -15,6 +15,8 @@ module Restforce
         :@timestamp_cache,
         :cache_timestamp,
         :changed?,
+        :dump_timestamps,
+        :load_timestamps,
       )
 
       # Public: Initialize a new Restforce::DB::Runner.

data/lib/restforce/db/task_manager.rb

@@ -0,0 +1,96 @@
+require "restforce/db/loggable"
+require "restforce/db/task"
+require "restforce/db/accumulator"
+require "restforce/db/attacher"
+require "restforce/db/associator"
+require "restforce/db/cleaner"
+require "restforce/db/collector"
+require "restforce/db/initializer"
+require "restforce/db/synchronizer"
+
+module Restforce
+
+  # :nodoc:
+  module DB
+
+    # TaskMapping is a small data structure used to pass top-level task
+    # information through to a SynchronizationError when necessary.
+    TaskMapping = Struct.new(:id, :mapping)
+
+    # Restforce::DB::TaskManager defines the run sequence and invocation of each
+    # of the Restforce::DB::Task subclasses during a single processing loop for
+    # the top-level Worker object.
+    class TaskManager
+
+      include Loggable
+
+      # Public: Initialize a new Restforce::DB::TaskManager for a given runner
+      # state.
+      #
+      # runner - A Restforce::DB::Runner for a specific period of time.
+      # logger - A Logger object (optional).
+      def initialize(runner, logger: nil)
+        @runner = runner
+        @logger = logger
+        @changes = Hash.new { |h, k| h[k] = Accumulator.new }
+      end
+
+      # Public: Run each of the sync tasks in a defined order for the supplied
+      # runner's current state.
+      #
+      # Returns nothing.
+      def perform
+        Registry.each do |mapping|
+          run("CLEANING RECORDS", Cleaner, mapping)
+          run("ATTACHING RECORDS", Attacher, mapping)
+          run("PROPAGATING RECORDS", Initializer, mapping)
+          run("COLLECTING CHANGES", Collector, mapping)
+        end
+
+        # NOTE: We can only perform the synchronization after all record changes
+        # have been aggregated, so this second loop is necessary.
+        Registry.each do |mapping|
+          run("UPDATING ASSOCIATIONS", Associator, mapping)
+          run("APPLYING CHANGES", Synchronizer, mapping)
+        end
+      end
+
+      private
+
+      # Internal: Log a description and response time for a specific named task.
+      #
+      # name       - A String task name.
+      # task_class - A Restforce::DB::Task subclass.
+      # mapping    - A Restforce::DB::Mapping.
+      #
+      # Returns a Boolean.
+      def run(name, task_class, mapping)
+        log "  #{name} between #{mapping.database_model.name} and #{mapping.salesforce_model}"
+        runtime = Benchmark.realtime { task task_class, mapping }
+        log format("  FINISHED #{name} after %.4f", runtime)
+
+        true
+      rescue => e
+        error(e)
+
+        false
+      end
+
+      # Internal: Run the passed mapping through the supplied Task class.
+      #
+      # task_class - A Restforce::DB::Task subclass.
+      # mapping    - A Restforce::DB::Mapping.
+      #
+      # Returns nothing.
+      def task(task_class, mapping)
+        task_class.new(mapping, @runner).run(@changes)
+      rescue Faraday::Error::ClientError => e
+        task_mapping = TaskMapping.new(task_class, mapping)
+        error SynchronizationError.new(e, task_mapping)
+      end
+
+    end
+
+  end
+
+end

data/lib/restforce/db/timestamp_cache.rb

@@ -71,6 +71,26 @@ module Restforce
         @cache = {}
       end
 
+      # Public: Load the previous collection of cached timestamps from the
+      # passed readable object.
+      #
+      # io - An IO object opened for reading.
+      #
+      # Returns nothing.
+      def load_timestamps(io)
+        @cache = YAML.load(io.read) || {}
+      end
+
+      # Public: Dump the currently cached timestamps into the specified
+      # writable object.
+      #
+      # io - An IO object opened for writing.
+      #
+      # Returns nothing.
+      def dump_timestamps(io)
+        io.write(YAML.dump(@cache))
+      end
+
       private
 
       # Internal: Get a unique cache key for the passed instance.

data/lib/restforce/db/version.rb

@@ -3,7 +3,7 @@ module Restforce
   # :nodoc:
   module DB
 
-    VERSION = "3.5.0"
+    VERSION = "4.0.0"
 
   end
 

data/lib/restforce/db/worker.rb

@@ -1,23 +1,29 @@
 require "file_daemon"
+require "forked_process"
+require "restforce/db/task_manager"
+require "restforce/db/loggable"
 
 module Restforce
 
-  # :nodoc:
   module DB
 
-    # TaskMapping is a small data structure used to pass top-level task
-    # information through to a SynchronizationError when necessary.
-    TaskMapping = Struct.new(:id, :mapping)
-
     # Restforce::DB::Worker represents the primary polling loop through which
     # all record synchronization occurs.
     class Worker
 
       include FileDaemon
+      include Loggable
 
       DEFAULT_INTERVAL = 5
       DEFAULT_DELAY = 1
 
+      # TERM and INT signals should trigger a graceful shutdown.
+      GRACEFUL_SHUTDOWN_SIGNALS = %w(TERM INT).freeze
+
+      # HUP and USR1 will reopen all files at their original paths, to
+      # accommodate log rotation.
+      ROTATION_SIGNALS = %w(HUP USR1).freeze
+
       attr_accessor :logger, :tracker
 
       # Public: Initialize a new Restforce::DB::Worker.
@@ -27,7 +33,6 @@ module Restforce
       #           interval - The maximum polling loop rest time.
       #           delay    - The amount of time by which to offset queries.
       #           config   - The path to a client configuration file.
-      #           verbose  - Display command line output? Defaults to false.
       def initialize(options = {})
         @options = options
         @interval = @options.fetch(:interval) { DEFAULT_INTERVAL }
@@ -45,7 +50,10 @@ module Restforce
           config.logger = logger
         end
 
-        %w(TERM INT).each { |signal| trap(signal) { stop } }
+        GRACEFUL_SHUTDOWN_SIGNALS.each { |signal| trap(signal) { stop } }
+        ROTATION_SIGNALS.each { |signal| trap(signal) { Worker.reopen_files } }
+
+        preload
 
         loop do
           runtime = Benchmark.realtime { perform }
@@ -66,28 +74,58 @@ module Restforce
 
       private
 
+      # Internal: Populate the field cache for each Salesforce object in the
+      # defined mappings.
+      #
+      # NOTE: To work around thread-safety issues with Typheous (and possibly
+      # some other HTTP adapters, we need to fork our preloading to prevent
+      # intialization of our Client object in the context of the master Worker
+      # process.
+      #
+      # Returns a Hash.
+      def preload
+        forked = ForkedProcess.new
+
+        forked.write do |writer|
+          log "INITIALIZING..."
+          FieldProcessor.preload
+          YAML.dump(FieldProcessor.field_cache, writer)
+        end
+
+        forked.read do |reader|
+          FieldProcessor.field_cache.merge!(YAML.load(reader.read))
+        end
+
+        forked.run
+      end
+
       # Internal: Perform the synchronization loop, recording the time that the
       # run is performed so that future runs can pick up where the last run
       # left off.
       #
+      # NOTE: In order to keep our long-term memory usage in check, we fork a
+      # task manager to process the tasks for each synchronization loop. Once
+      # the subprocess dies, its memory can be reclaimed by the OS.
+      #
       # Returns nothing.
       def perform
+        reset!
+
         track do
-          reset!
+          forked = ForkedProcess.new
+
+          forked.write do |writer|
+            Worker.after_fork
+            task_manager.perform
 
-          Restforce::DB::Registry.each do |mapping|
-            run("CLEANING RECORDS", Cleaner, mapping)
-            run("ATTACHING RECORDS", Attacher, mapping)
-            run("PROPAGATING RECORDS", Initializer, mapping)
-            run("COLLECTING CHANGES", Collector, mapping)
+            runner.dump_timestamps(writer)
           end
 
-          # NOTE: We can only perform the synchronization after all record
-          # changes have been aggregated, so this second loop is necessary.
-          Restforce::DB::Registry.each do |mapping|
-            run("UPDATING ASSOCIATIONS", Associator, mapping)
-            run("APPLYING CHANGES", Synchronizer, mapping)
+          forked.read do |reader|
+            runner.load_timestamps(reader)
           end
+
+          forked.run
         end
       end
 
@@ -97,7 +135,15 @@ module Restforce
       # Returns nothing.
       def reset!
         runner.tick!
-        @changes = Hash.new { |h, k| h[k] = Accumulator.new }
+        Worker.before_fork
+      end
+
+      # Internal: Get a new TaskManager instance, which reflects the current
+      # runner state.
+      #
+      # Returns a Restforce::DB::TaskManager.
+      def task_manager
+        TaskManager.new(runner, logger: logger)
       end
 
       # Internal: Run the passed block, updating the tracker with the time at
@@ -115,9 +161,9 @@ module Restforce
             log "SYNCHRONIZING"
           end
 
-          yield
+          duration = Benchmark.realtime { yield }
+          log format("DONE after %.4f", duration)
 
-          log "DONE"
           tracker.track(runtime)
         else
           yield
@@ -132,38 +178,6 @@ module Restforce
         @runner ||= Runner.new(@options.fetch(:delay) { DEFAULT_DELAY })
       end
 
-      # Internal: Log a description and response time for a specific named task.
-      #
-      # name       - A String task name.
-      # task_class - A Restforce::DB::Task subclass.
-      # mapping    - A Restforce::DB::Mapping.
-      #
-      # Returns a Boolean.
-      def run(name, task_class, mapping)
-        log "  #{name} between #{mapping.database_model.name} and #{mapping.salesforce_model}"
-        runtime = Benchmark.realtime { task task_class, mapping }
-        log format("  COMPLETE after %.4f", runtime)
-
-        true
-      rescue => e
-        error(e)
-
-        false
-      end
-
-      # Internal: Run the passed mapping through the supplied Task class.
-      #
-      # task_class - A Restforce::DB::Task subclass.
-      # mapping    - A Restforce::DB::Mapping.
-      #
-      # Returns nothing.
-      def task(task_class, mapping)
-        task_class.new(mapping, runner).run(@changes)
-      rescue Faraday::Error::ClientError => e
-        task_mapping = TaskMapping.new(task_class, mapping)
-        error SynchronizationError.new(e, task_mapping)
-      end
-
       # Internal: Has this worker been instructed to stop?
       #
       # Returns a boolean.
@@ -171,29 +185,6 @@ module Restforce
         @exit == true
       end
 
-      # Internal: Log the passed text at the specified level.
-      #
-      # text  - The piece of text which should be logged for this worker.
-      # level - The level at which the text should be logged. Defaults to :info.
-      #
-      # Returns nothing.
-      def log(text, level = :info)
-        puts text if @options[:verbose]
-
-        return unless logger
-        logger.send(level, text)
-      end
-
-      # Internal: Log an error for the worker, outputting the entire error
-      # stacktrace and applying the appropriate log level.
-      #
-      # exception - An Exception object.
-      #
-      # Returns nothing.
-      def error(exception)
-        logger.error(exception)
-      end
-
     end
 
   end

data/lib/restforce/db.rb

@@ -39,18 +39,10 @@ require "restforce/db/record_cache"
 require "restforce/db/timestamp_cache"
 require "restforce/db/runner"
 
-require "restforce/db/task"
-require "restforce/db/accumulator"
-require "restforce/db/attacher"
 require "restforce/db/adapter"
-require "restforce/db/associator"
 require "restforce/db/attribute_map"
-require "restforce/db/cleaner"
-require "restforce/db/collector"
-require "restforce/db/initializer"
 require "restforce/db/mapping"
 require "restforce/db/model"
-require "restforce/db/synchronizer"
 require "restforce/db/tracker"
 require "restforce/db/worker"
 
@@ -89,7 +81,7 @@ module Restforce
     # Returns a Restforce::Data::Client instance.
     def self.client
       @client ||= begin
-        client = DB::Client.new(
+        DB::Client.new(
           username:       configuration.username,
           password:       configuration.password,
           security_token: configuration.security_token,
@@ -100,36 +92,9 @@ module Restforce
           timeout:        configuration.timeout,
           adapter:        configuration.adapter,
         )
-        setup_middleware(client)
-        client
       end
     end
 
-    # Internal: Sets up the Restforce client's middleware handlers.
-    #
-    # Returns nothing.
-    def self.setup_middleware(client)
-      # NOTE: By default, the Retry middleware will catch timeout exceptions,
-      # and retry up to two times. For more information, see:
-      # https://github.com/lostisland/faraday/blob/master/lib/faraday/request/retry.rb
-      client.middleware.insert(
-        -2,
-        Faraday::Request::Retry,
-        methods: [:get, :head, :options, :put, :patch, :delete],
-      )
-
-      client.middleware.insert_after(
-        Restforce::Middleware::InstanceURL,
-        FaradayMiddleware::Instrumentation,
-        name: "request.restforce_db",
-      )
-
-      client.middleware.insert_before(
-        FaradayMiddleware::Instrumentation,
-        Restforce::DB::Middleware::StoreRequestBody,
-      )
-    end
-
     # Public: Get the ID of the Salesforce user which is being used to access
     # the Salesforce API.
     #

data/test/lib/restforce/db/timestamp_cache_test.rb

@@ -84,4 +84,34 @@ describe Restforce::DB::TimestampCache do
     end
   end
 
+  describe "I/O operations" do
+    let(:io) { IO.pipe }
+    let(:reader) { io.first }
+    let(:writer) { io.last }
+
+    describe "#dump_timestamps" do
+      before do
+        cache.cache_timestamp instance
+        cache.dump_timestamps(writer)
+        writer.close
+      end
+
+      it "writes a YAML dump of the cache to the passed I/O object" do
+        expect(YAML.load(reader.read)).to_equal [record_type, id] => timestamp
+      end
+    end
+
+    describe "#load_timestamps" do
+      before do
+        YAML.dump({ [record_type, id] => timestamp }, writer)
+        writer.close
+        cache.load_timestamps(reader)
+      end
+
+      it "reloads its internal cache from the passed I/O object" do
+        expect(cache.timestamp(instance)).to_equal timestamp
+      end
+    end
+  end
+
 end

data/test/lib/restforce/db/worker_test.rb

@@ -20,7 +20,8 @@ describe Restforce::DB::Worker do
 
       ## 1b. The record is synced to Salesforce.
       worker.send :reset!
-      worker.send :task, Restforce::DB::Initializer, mapping
+      manager = worker.send(:task_manager)
+      manager.send :task, Restforce::DB::Initializer, mapping
 
       expect(database_record.reload).to_be :salesforce_id?
       Salesforce.records << [salesforce_model, database_record.salesforce_id]
@@ -44,8 +45,9 @@ describe Restforce::DB::Worker do
         # We sleep here to ensure we pick up our manual changes.
         sleep 1 if VCR.current_cassette.recording?
         worker.send :reset!
-        worker.send :task, Restforce::DB::Collector, mapping
-        worker.send :task, Restforce::DB::Synchronizer, mapping
+        manager = worker.send(:task_manager)
+        manager.send :task, Restforce::DB::Collector, mapping
+        manager.send :task, Restforce::DB::Synchronizer, mapping
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restforce-db
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Andrew Horner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-11 00:00:00.000000000 Z
+date: 2015-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -201,6 +201,7 @@ files:
 - bin/setup
 - circle.yml
 - lib/file_daemon.rb
+- lib/forked_process.rb
 - lib/generators/restforce/install_generator.rb
 - lib/generators/restforce/migration_generator.rb
 - lib/generators/templates/config.yml
@@ -231,6 +232,7 @@ files:
 - lib/restforce/db/instances/active_record.rb
 - lib/restforce/db/instances/base.rb
 - lib/restforce/db/instances/salesforce.rb
+- lib/restforce/db/loggable.rb
 - lib/restforce/db/mapping.rb
 - lib/restforce/db/middleware/store_request_body.rb
 - lib/restforce/db/model.rb
@@ -248,6 +250,7 @@ files:
 - lib/restforce/db/synchronization_error.rb
 - lib/restforce/db/synchronizer.rb
 - lib/restforce/db/task.rb
+- lib/restforce/db/task_manager.rb
 - lib/restforce/db/timestamp_cache.rb
 - lib/restforce/db/tracker.rb
 - lib/restforce/db/version.rb