Event batching for the C# SDK

The Optimizely Feature Experimentation C# SDK uses the event processor to batch decisions and conversion events into a single payload before sending it.

The C# SDK lets you batch events and includes options to set an event batch size, event time interval and event flush interval. The benefit of event batching is less network traffic for the same number of impression and conversion events tracked.

In the C# SDK,BatchEventProcessor provides the implementation of theEventProcessor interface and batches events. You can control batching based on two parameters:

Batch size – Defines the number of batched events before sending to Optimizely Feature Experimentation.
Flush interval – Defines the amount of time after which any batched events should be sent to Optimizely Feature Experimentation.

An event consisting of the batched payload is sent as soon as the batch size reaches the specified limit or the flush interval reaches the specified time limit.BatchEventProcessor options are described in the following sections.

📘
Note
Event batching works with both out-of-the-box and custom event dispatchers.
The event batching process does not remove any personally identifiable information (PII) from events. You must still ensure that you are not sending any unnecessary PII to Optimizely Feature Experimentation.

Basic example

using OptimizelySDK;public static class Program{   public static void Main(string[] args)    {        var sdkKey = args[0];                // Returns Optimizely Client        OptimizelyFactory.NewDefaultInstance(sdkKey);    }}

By default, the batch size is 10 and the flush interval is 30 seconds.

Advanced example

using OptimizelySDK;using OptimizelySDK.Config;using OptimizelySDK.Event;public static class Program{    public static void Main(string[] args)    {        var sdkKey = args[0];                var projectConfigManager = HttpProjectConfigManager.Builder()            .WithSdkKey(sdkKey)            .Build();        var batchEventProcessor = new BatchEventProcessor.Builder()            .WithMaxBatchSize(10)            .WithFlushInterval(TimeSpan.FromSeconds(30))            .Build();        var optimizely = new Optimizely(            configManager: projectConfigManager,            // ... Other parameters            eventProcessor: batchEventProcessor        );    }}

❗️
Warning
The maximum payload size is 3.5 MB. Optimizely rejects requests with a 400 response code,Bad Request Error, if the batch payload exceeds this limit.
The size limitation is because of theOptimizely Events API, which Feature Experimentation uses to send data to Optimizely.
The most common cause of a large payload size is a high batch size. If your payloads exceed the size limit, try configuring a smaller batch size.

`BatchEventProcessor`

BatchEventProcessor is an implementation ofEventProcessor where events are batched. The class maintains a single consumer thread that pulls events off of theBlockingCollection and buffers them for either a configured batch size or a maximum duration before the resultingLogEvent is sent to theEventDispatcher andNotificationCenter.

The following properties can be used to customize the BatchEventProcessor configurationusing the Builder class

Property	Default value	Description
EventDispatcher	DefautEventDispatcher	Used to dispatch event payload to Optimizely Feature Experimentation.
BatchSize	10	The maximum number of events to batch before dispatching. Once this number is reached, all queued events are flushed and sent to Optimizely Feature Experimentation.
FlushInterval	30000 (30 Seconds)	Milliseconds to wait before batching and dispatching events.
EventQueue	1000	BlockingCollection that queues individual events to be batched and dispatched by the executor.
NotificationCenter	null	Notification center instance to be used to trigger any notifications.

For more information, seeInitialize the C# SDK.

Side effects

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

Functionality

Description

LogEvent (see following section)

Whenever the event processor produces a batch of events, aLogEvent object will be created using theEventFactory.

It contains batch of conversion and decision 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 theLOGEVENTnotification listener if this listener is subscribed to.

Register LogEvent listener

To register aLogEvent listener:

NotificationCenter.AddNotification(    NotificationCenter.NotificationType.LogEvent,     new NotificationCenter.LogEventCallback((logevent) => {        // Your code here    }));

`LogEvent`

LogEvent object gets created usingEventFactory. It represents the batch of decision and conversion events we send to the Optimizely Feature Experimentation backend.

Object	Type	Description
UrlRequired	string	URL to dispatch log event to.
Params Required	Dictionary<string, object>	Parameters to be set in the log event. It contains`EventBatch` of all`UserEvents` inside`Visitors`.
HttpVerb Required	string	The HTTP verb to use when dispatching the log event. It can be`GET` or`POST`.
Headers	Dictionary<string, string> Headers	Headers to be set when sending the request.

Dispose Optimizely Feature Experimentation on application exit

If you enable event batching,you must call the Close method (optimizely.Dispose()) before exiting. This ensures that queued events are flushed as soon as possible to avoid data loss.

❗
Warning
Because the Optimizely Feature Experimentation client maintains a buffer of queued events, you must callDispose() on the instance before shutting down your application or whenever dereferencing the instance.

Method	Description
Dispose()	Stops all timers and flushes the event queue. This method will also stop any timers that are happening for the data-file manager.

Updated 17 days ago

Note