class FacebookAds::ServerSide::BatchProcessor

Attributes

batch_size[RW]
concurrent_requests[RW]

Public Class Methods

new(batch_size=50, concurrent_requests=4) click to toggle source

Initializes the object @param [Integer] batch_size The number of events to send in each request @param [Integer] concurrent_requests The number of threads to use when making requests concurrently

# File lib/facebook_ads/ad_objects/server_side/batch_processor.rb, line 27
def initialize(batch_size=50, concurrent_requests=4)
  self.batch_size = batch_size
  self.concurrent_requests = concurrent_requests
end

Public Instance Methods

process_event_requests(event_requests_async) click to toggle source
# File lib/facebook_ads/ad_objects/server_side/batch_processor.rb, line 32
def process_event_requests(event_requests_async)
  generator = self.process_event_requests_generator(event_requests_async)
  generator.each do |batch|
    Concurrent::Promise.zip(*batch).execute.value!
  end
end
process_event_requests_generator(event_requests_async) click to toggle source
# File lib/facebook_ads/ad_objects/server_side/batch_processor.rb, line 46
def process_event_requests_generator(event_requests_async)
  index = 0
  Enumerator.new do |generator|
    while index < event_requests_async.size do
      batch = event_requests_async[index, concurrent_requests].map(&:execute)
      generator.yield *[batch]
      index += concurrent_requests
    end
  end
end
process_events(event_request_async_to_clone, events) click to toggle source
# File lib/facebook_ads/ad_objects/server_side/batch_processor.rb, line 39
def process_events(event_request_async_to_clone, events)
  generator = self.process_events_generator(event_request_async_to_clone, events)
  generator.each do |batch|
    Concurrent::Promise.zip(*batch).execute.value!
  end
end
process_events_generator(event_request_async_to_clone, events) click to toggle source
# File lib/facebook_ads/ad_objects/server_side/batch_processor.rb, line 57
def process_events_generator(event_request_async_to_clone, events)
  index = 0
  Enumerator.new do |generator|
    while index < events.size do
      batch = []
      while index < events.size && batch.size < concurrent_requests do
        event_request_async = event_request_async_to_clone.clone_without_events
        event_request_async.events = events[index, batch_size]
        batch << event_request_async
        index += batch_size
      end
      generator.yield *[batch.map(&:execute)]
    end
  end
end