Flushing events

Internally, the client-side .NET SDK keeps an event buffer for Track and Identify calls. These are flushed periodically in a background thread. If you test the SDK in a REPL, you may want to manually call Flush to process events immediately.

The flush interval is configurable. If you need to change the interval, you can do so with the Configuration class.

To call flush:

1
client.Flush();

The Android SDK keeps an internal event buffer for analytics calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately. This call is non-blocking, so it returns before the events are sent.

Here’s how:

1
client.flush();

The flush interval is configurable.

The LaunchDarkly SDK keeps an internal event buffer for analytics events. These are flushed periodically in a background thread. In some situations, for example if you’re testing the SDK in a simulator, you may want to manually call flush to process events immediately.

1
client.FlushAsync();

You can also examine the result to determine if the flush succeeded. Here’s how:

1
auto flush_result = client.FlushAsync(context);
2
auto status = flush_result.wait_for(maxwait);
3
4
if (status == std::future_status::ready) {
5
  /* The client's attempt to flush succeeded or failed in the specified amount of time. */
6
  if (flush_result.get()) {
7
    /* Flush succeeded */
8
  } else {
9
    /* Flush failed */
10
  }
11
} else {
12
  /* The specified timeout was reached, but the client is still attempting to flush. */
13
}

The flush interval is configurable. If you need to change the interval, you can do so using the configuration. To learn more, read FlushAsync and FlushInterval.

Internally, the Flutter SDK keeps an event buffer for track calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately. This call is non-blocking, so it returns before the events are sent.

To call flush:

1
await client.flush();

To learn more, read flush.

Internally, the iOS SDK keeps an event buffer for track calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately. This call is non-blocking, so it returns before the events are sent.

To call flush:

1
LDClient.get()!.flush()

Internally, the JavaScript SDK keeps an event buffer for track calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately. This call is non-blocking, so it returns before the events are sent.

This method is asynchronous. You can pass a callback or wait for the returned Promise to determine when all events have been flushed.

To call flush:

1
client.flush();

Internally, the LaunchDarkly SDK keeps an analytics event buffer. These events are flushed periodically. In some situations, you may want to manually call flush to process events immediately.

This method is asynchronous. You can pass a callback or wait for the returned Promise to determine when all events have been flushed.

To call flush:

1
client.flush();
2
3
// or, with a callback:
4
client.flush(() => {
5
  console.log('flush complete');
6
});
7
8
// or, with a Promise:
9
client.flush().then(() => {
10
  console.log('flush complete');
11
});

Internally, the React Native SDK keeps an event buffer for track calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately.

To call flush:

1
const { result, error } = await client.flush();

flush is asynchronous and can be awaited. It returns a promise that resolves to an object containing an error, if there is one, and a boolean result.

To learn more, read flush.

Internally, the Roku SDK keeps an event buffer for track calls. These are flushed periodically in a background thread. You can configure the flush interval if needed.

In some situations, such as when you’re testing the SDK in a simulator, you may want to manually call flush to request any queued events to be sent immediately. This call is non-blocking, so it returns before the events are sent.

To call flush:

1
launchDarkly.flush()

The .NET (server-side) SDK supports asynchronous flushing with the Flush method.

To call flush:

1
client.Flush();

Starting in version 7.0.0, the SDK also supports synchronous flushing with the FlushAndWait method. In this example, the TimeSpan.FromSeconds(2) value means that the application is willing to wait no more than two seconds for event delivery.

1
client.FlushAndWait(TimeSpan.FromSeconds(2));

The flush interval is configurable. If you need to change the interval, you can do so with the Configuration class.

Here’s how:

1
var config = Configuration.Builder("sdk-key-123abc")
2
    .Events(
3
        Components.SendEvents().FlushInterval(TimeSpan.FromSeconds(10))
4
    )
5
    .Build();
6
var client = new LdClient(config);

The LaunchDarkly SDK keeps an internal event buffer for analytics events. These are flushed periodically in a background thread. If you test the SDK in a simulator, you may want to manually call flush to process events immediately.

This function will not block, but instead initiate a flush operation in the background. The flush interval is configurable. If you need to change the interval, you can do so with the configuration.

Here’s how:

1
client.FlushAsync();

The flush interval is configurable. If you need to change the interval, you can do so using the configuration. To learn more, read about FlushAsync() in Client and about FlushInterval() in EventsBuilder.

The Go SDK supports asynchronous flushing with the Flush method.

1
client.Flush();

Starting in version 6.0.0, the SDK also supports synchronous flushing with the FlushAndWait method. In this example, the time.Second*2 value means that the application is willing to wait no more than two seconds for event delivery.

1
client.FlushAndWait(time.Second*2);

The interval for automatic event flushing is configurable. If you need to change the interval, you can do so by making a custom client configuration. Here’s how:

1
config := ld.Config{
2
    Events: ldcomponents.SendEvents().FlushInterval(time.Second*10),
3
}

The LaunchDarkly SDK keeps an internal event buffer for analytics events. These events are flushed periodically in a background thread. If you test the SDK in a simulator, you may want to manually call flush to process events immediately.

This function will not block, but instead initiate a flush operation in the background. The flush interval is configurable. If you need to change the interval, you can do so with the configuration.

Here’s how:

1
flushEvents client

Internally, the LaunchDarkly SDK keeps an event buffer for track and identify calls. These are flushed periodically in a background thread. If you test the SDK in a REPL, you may want to manually call flush to process events immediately.

Here’s how:

1
client.flush();

The flush interval is configurable. If you need to change the interval, you can do so with LDConfig.Builder and Components.sendEvents().

The LaunchDarkly SDK keeps an internal event buffer for analytics events. These are flushed periodically in a background thread. If you test the SDK in a simulator, you may want to manually call flush to process events immediately.

This function will not block, but instead initiate a flush operation in the background. The flush interval is configurable. If you need to change the interval, you can do so with the configuration.

Here’s how:

1
client:flush()

To learn more, read flush.

Internally, the LaunchDarkly SDK keeps an event buffer for track and identify calls. These are flushed periodically in a background thread. If you test the SDK in a REPL, you may want to manually call flush to process events immediately.

The flush interval is configurable. If you need to change the interval, you can do so when configuring your client instance.

Here’s how:

1
client.flush();

Internally, the LaunchDarkly SDK keeps an event buffer for variation, track, and identify calls. These are automatically flushed when the LDClient is destroyed. PHP’s shared-nothing architecture means manual invocation of this method is typically not needed. Developers may do so if they wish to flush events prior to teardown.

Here’s how:

1
ldclient->flush();

Internally, the LaunchDarkly SDK keeps an event buffer for variation, track, and identify calls. These are flushed periodically in a background thread. If you test the SDK in a REPL, you may want to manually call flush to process events immediately. Otherwise, Python may close before flushing the event buffer and your user changes and tracks will be lost.

The flush interval is configurable. If you need to change the interval, you can do so when you configure your client instance.

Here’s how:

1
ldclient.get().flush()

Internally, the LaunchDarkly SDK keeps an event buffer for track and identify calls. These are flushed periodically in a background thread. If you test the SDK in a REPL, you may want to manually call flush to process events immediately.

The flush interval is configurable. If you need to change the interval, you can do so when you configure your client instance.

Here’s how:

1
client.flush

Internally, the LaunchDarkly SDK keeps an event buffer for the analytics events that are produced by calling the variation or variation_detail methods, the track methods, or identify. These are flushed periodically in a background thread. In some situations, you may want to manually call flush to process events immediately.

The flush interval is configurable. If you need to change the interval, you can do so by making a custom client configuration.

Here’s how:

1
let result = client.flush();

Flushing events is available in Cloudflare SDK version 2.3.0 and later.

If you send events, you must also flush those events before your worker exits to ensure that they are sent back to LaunchDarkly.

If you call flush inside the waitUntil method, then flushing events will not impact the handler’s response time. To learn more, read the Cloudflare documentation on waitUntil.

Here’s how:

1
// executionContext is the Cloudflare worker handler context
2
// https://github.com/cloudflare/workers-types/blob/master/index.d.ts#L567
3
executionContext.waitUntil(
4
  client.flush((err, res) => {
5
    console.log(`flushed events result: ${res}, error: ${err}`);
6
  }),
7
);

If you do not call flush, the events will not be sent to LaunchDarkly servers, due to the ephemeral nature of edge workers.

Flushing events is available in Vercel SDK v1.2.0 and later.

If you send events, you must also flush those events before your worker exits to ensure that they are sent back to LaunchDarkly.

If you call flush inside the waitUntil method, then flushing events will not impact the handler’s response time. To learn more, read the Vercel documentation on waitUntil.

Here’s how:

1
context.waitUntil(
2
  client.flush((err, res) => {
3
    console.log(`flushed events result: ${res}, error: ${err}`);
4
  }),
5
);

If you do not call flush, the events will not be sent to LaunchDarkly servers, due to the ephemeral nature of edge workers.