Event batching

The Optimizely Full Stack Python SDK lets you batch events and includes options to set a maximum batch size and flush interval timeout. The benefit of event batching means less network traffic for the same number of impression and conversion events tracked.

The event batching functionality works by processing impression events from Activate, Is Feature Enabled and conversion events from Track and placing them into a queue. The queue is drained when it either reaches its maximum size limit or when the flush interval is triggered.

By default, event batching is disabled in Python SDK 3.3.0. Follow along to learn how to take advantage of event batching in the Python SDK.

πŸ“˜

Note

Event batching works with both out-of-the-box and custom event dispatchers.

Make sure that you aren't sending personally identifiable information (PII) to Optimizely. The event batching process doesn't remove PII from events.

Configure event batching

Event batching can be enabled through the usage of BatchEventProcessor. We provide two main options to configure event batching: batch_size and flush_interval. You can pass in both these options when creating instance of BatchEventProcessor and pass the created instance during Optimizely client creation. When using BatchEventProcessor, events are held in a queue until either:

  • The number of events reaches the defined batch_size.
  • The oldest event has been in the queue for longer than the defined flush_interval, which is specified in seconds. The queue is then flushed and all queued events are sent to Optimizely in a single network request.
  • A new datafile revision is received. This occurs only when live datafile updates are enabled. See Enable automatic datafile updates.
from optimizely import optimizely
from optimizely import event_dispatcher as optimizely_event_dispatcher
from optimizely.event import event_processor

# Set event dispatcher that the 
# You can reference your own implementation of event dispatcher here
event_dispatcher = optimizely_event_dispatcher.EventDispatcher

# Create instance of BatchEventProcessor.
#
# In this example here we set batch size to 15 events
# and flush interval to 50 seconds. 
# Setting start_on_init starts the consumer
# thread to start receiving events.
#
# See table below for explanation of these
# and other configuration options.  
batch_processor = event_processor.BatchEventProcessor(
    event_dispatcher,
    batch_size=15,
    flush_interval=50
    start_on_init=True,
)

# Create Optimizely client and pass in instance 
# of BatchEventProcessor to enable batching.
optimizely_client = optimizely.Optimizely(
    sdk_key='<Your SDK Key here>', 
    datafile='<Your datafile here>',
    event_processor=batch_processor
)

The table below defines these and other options that you can use to configure the BatchEventProcessor.

Name

Default value

Description

event_dispatcher

No default value. Required parameter.

An event handler to manage network calls.

Provides a dispatch_event method that takes in URL and parameters and dispatches request.

logger
optional

NoOpLogger

A logger implementation to log issues.

flush_interval
optional

30

The maximum duration in seconds that an event can exist in the queue before being flushed.

batch_size
optional

10

The maximum number of events to hold in the queue. Once this number is reached, all queued events are flushed and sent to Optimizely.

start_on_init
optional

False

Boolean which if set true starts the thread consuming and queuing events on initializing the BatchEventProcessor.

By default the value is False and so the consumer thread is not ready to receive any events. One can always start the consumer thread by calling start on the instance of BatchEventProcessor

timeout_interval
optional

5

Number representing time interval in seconds before joining the consumer thread.

event_queue
optional

six.moves.queue.Queue

Component that allows you to accumulate events until they are dispatched.

notification_center
optional

NotificationCenter

Instance of optimizely.notification_center.NotificationCenter.

By default an instance of notification_center.NotificationCenter is created.

For more information, see Initialize SDK.

πŸ“˜

Note

The maximum payload size is 10 MB. If the resulting batch payload exceeds this limit, requests will be rejected with a 400 response code, Bad Request Error.

Side effects

The table lists other Optimizely functionality that may be triggered by using this class.

Functionality

Description

LogEvent

Whenever the event processor produces a batch of events, a LogEvent object will be created using the EventFactory.
It contains batch of conversion and impression events.
This object will be dispatched using the provided event dispatcher and also it will be sent to the notification subscribers.

Notification Listeners

Flush invokes the LOG_EVENT notification listener if this listener is subscribed to.

Registering LogEvent listener

To register a LogEvent notification listener

def on_log_event():
  pass

optimizely_client.notification_center.add_notification_listener(enums.NotificationTypes.LOG_EVENT, on_log_event)

LogEvent

LogEvent object gets created using EventFactory. It represents the batch of impression and conversion events we send to the Optimizely backend.

Object

Type

Description

http_verb
Required (non null)

String

The HTTP verb to use when dispatching the log event. It can be Get or Post.

url
Required (non null)

String

URL to dispatch log event to.

params
Required (non null)

Dict

Event Batch. It contains all the information regarding every event which is batched. including list of visitors which contains UserEvent.

headers

Dict

Request Headers

Stop BatchEventProcessor on application exit

If you enable event batching, it's important that you call the 'stop' method, batch_processor.stop(), prior to exiting. This ensures that queued events are flushed as soon as possible to avoid any data loss.

🚧

Important

Because the BatchEventProcessor maintains a buffer of queued events, we recommend that you call stop() on the BatchEventProcessor instance before shutting down your application.

Method

Description

stop()

Stops and flushes the event queue.

Note: We recommend that you connect this method to a kill signal for the running process.


Did this page help you?