Class: Mixpanel::BufferedConsumer

Inherits:
Object
  • Object
show all
Defined in:
lib/mixpanel-ruby/consumer.rb

Overview

BufferedConsumer buffers messages in memory, and sends messages as a batch. This can improve performance, but calls to #send! may still block if the buffer is full. If you use this consumer, you should call #flush when your application exits or the messages remaining in the buffer will not be sent.

To use a BufferedConsumer directly with a Mixpanel::Tracker, instantiate your Tracker like this

buffered_consumer = Mixpanel::BufferedConsumer.new
begin
   buffered_tracker = Mixpanel::Tracker.new(YOUR_MIXPANEL_TOKEN) do |type, message|
       buffered_consumer.send!(type, message)
   end
   # Do some tracking here
   ...
ensure
   buffered_consumer.flush
end

Constant Summary collapse

MAX_LENGTH = 
50

Instance Method Summary collapse

Constructor Details

#initialize(events_endpoint = nil, update_endpoint = nil, import_endpoint = nil, max_buffer_length = MAX_LENGTH, credentials: nil, &block) ⇒ BufferedConsumer

Create a Mixpanel::BufferedConsumer. If you provide endpoint arguments, they will be used instead of the default Mixpanel endpoints. This can be useful for proxying, debugging, or if you prefer not to use SSL for your events.

You can also change the preferred buffer size before the consumer automatically sends its buffered events. The Mixpanel endpoints have a limit of 50 events per HTTP request, but you can lower the limit if your individual events are very large.

By default, BufferedConsumer will use a standard Mixpanel consumer to send the events once the buffer is full (or on calls to #flush), but you can override this behavior by passing a block to the constructor, in the same way you might pass a block to the Mixpanel::Tracker constructor. If a block is passed to the constructor, the *_endpoint constructor arguments are ignored.

Parameters:

  • credentials (ServiceAccountCredentials, nil) (defaults to: nil) —

    Service account credentials for authentication. Credentials are only used for the /import endpoint and feature flags.



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/mixpanel-ruby/consumer.rb', line 232

def initialize(events_endpoint=nil, update_endpoint=nil, import_endpoint=nil, max_buffer_length=MAX_LENGTH, credentials: nil, &block)
  @max_length = [max_buffer_length, MAX_LENGTH].min
  @buffers = {
    :event => [],
    :profile_update => [],
  }
  @credentials = credentials

  if block
    @sink = block
  else
    consumer = Consumer.new(events_endpoint, update_endpoint, nil, import_endpoint, credentials: credentials)
    @sink = consumer.method(:send!)
  end
end

Instance Method Details

#flush ⇒ Object

Pushes all remaining messages in the buffer to Mixpanel. You should call #flush before your application exits or messages may not be sent.



274
275
276
 
# File 'lib/mixpanel-ruby/consumer.rb', line 274

def flush
  @buffers.keys.each { |k| flush_type(k) }
end

#send(type, message) ⇒ Object

This method was deprecated in release 2.0.0, please use send! instead



266
267
268
269
 
# File 'lib/mixpanel-ruby/consumer.rb', line 266

def send(type, message)
    warn '[DEPRECATION] send has been deprecated as of release 2.0.0, please use send! instead'
    send!(type, message)
end

#send!(type, message) ⇒ Object

Stores a message for Mixpanel in memory. When the buffer hits a maximum length, the consumer will flush automatically. Flushes are synchronous when they occur.

Currently, only :event and :profile_update messages are buffered, :import messages will be send immediately on call.



254
255
256
257
258
259
260
261
262
263
 
# File 'lib/mixpanel-ruby/consumer.rb', line 254

def send!(type, message)
  type = type.to_sym

  if @buffers.has_key? type
    @buffers[type] << message
    flush_type(type) if @buffers[type].length >= @max_length
  else
    @sink.call(type, message)
  end
end