Monitoring SDK status

The client-side .NET SDK defines "data source status" as the status of the SDK's communication with LaunchDarkly to get feature flag data. If the streaming connection to LaunchDarkly is interrupted, or, in polling mode, if a polling request fails, the SDK might not be able to receive flag updates. The data source status will indicate this, providing an overall state such as "valid" or "interrupted" and information about the last error that occurred, if any.

To check the data source status:

var dataSourceStatus = client.DataSourceStatusProvider.Status;
COPY

Alternatively, you can register an event handler that will receive a new status value whenever the status changes.

Here is an example:

client.DataSourceStatusProvider.StatusChanged +=
    (sender, status) => {
        Console.WriteLine("new status is: {0}", status);
    };
COPY

To learn more, read IDataSourceStatusProvider.

The Android SDK exposes some of its internal status through APIs to let your application monitor it. This allows the application to determine how recently the internal flag cache has been updated with the most recent values, as well as diagnosing potential reasons for the flag cache to be out of date.

The SDK has seven connectivity states dependent on its configuration, application foreground state, network connectivity, and calls explicitly setting the client offline or online.

This table describes the states:

The SDK also internally stores a timestamp of the most recent successful and failed connections to LaunchDarkly, as well as information related to the most recent failed connection. The LDClient method getConnectionInformation() returns a structure allowing retrieval of these fields.

LDClient client = LDClient.get();
ConnectionInformation connectionInfo = client.getConnectionInformation();
// One of the seven modes described above
ConnectionInformation.ConnectionMode connectionMode =
  connectionInfo.getConnectionMode();
// Most recent successful flag cache update in millis from the epoch
// Or null if flags have never been retrieved
Long lastSuccess = connectionInfo.getLastSuccessfulConnection();
// Most recent unsuccessful flag cache update attempt in millis from the epoch
// Or null if flag update has never been attempted
Long lastError = connectionInfo.getLastFailedConnection();
// Most recent failure or null
LDFailure ldFailure = connectionInfo.getLastFailure();
COPY

LDFailure is a LaunchDarklyException with an associated FailureType. It may include a .cause(), which is propagated from an underlying exception associated with the update's failure. The cause itself should be considered unstable because it is dependent on internal implementation, though the mechanism to retrieve it will be maintained.

The failure types are summarized below:

If matching on the FailureType, use a default case to handle any future cases provided. The UNEXPECTED_RESPONSE_CODE case indicates that you can cast the LDFailure to a LDInvalidResponseCodeFailure for more information. This more specific failure includes a response code and whether the failure is considered retryable.

Here is an example:

LDClient client = LDClient.get();
ConnectionInformation connectionInfo = client.getConnectionInformation();
LDFailure ldFailure = connectionInfo.getLastFailure();
if (ldFailure != null) {
    Timber.d("Received failure with message %s", ldFailure.getMessage());
    // Retrieve the failure type
    LDFailure.FailureType failureType = ldFailure.getFailureType();
    switch (failureType) {
        case INVALID_RESPONSE_BODY:
            Timber.d("Received invalid response body");
            break;
        case NETWORK_FAILURE:
            Timber.d("Network failure, may have bad connection");
            break;
        case UNEXPECTED_STREAM_ELEMENT_TYPE:
            Timber.d("Unexpected stream element, may require update");
            break;
        case UNEXPECTED_RESPONSE_CODE:
            LDInvalidResponseCodeFailure responseCodeFailure =
                (LDInvalidResponseCodeFailure) ldFailure;
            int responseCode = responseCodeFailure.getResponseCode();
            if (responseCodeFailure.isRetryable()) {
                Timber.d("Received invalid response code %d", responseCode);
            } else {
                Timber.d("Received invalid response code %d, giving up", responseCode);
            }
            break;
        case UNKNOWN_ERROR:
        default:
            Timber.d("Unknown error");
            break;
    }
    Throwable cause = ldFailure.getCause();
    if (cause != null) {
        // Do something with underlying cause
    }
}
COPY

A callback-based interface is also provided to allow notifying the application when the ConnectionMode changes, as well as whenever the LDFailure in ConnectionStatus changes. The application must provide a class instance implementing LDStatusListener to the SDK client instance method registerStatusListener to register the listeners with the SDK.

Here is a brief example:

class MainActivity extends Activity {
    private LDClient client;
    private LDStatusListener ldStatusListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ldStatusListener = new LDStatusListener() {
            @Override
            public void onConnectionModeChanged(ConnectionInformation connectionInfo) {
                // handle new connection info
            }
            @Override
            public void onInternalFailure(LDFailure ldFailure) {
                // handle failure
            }
        };
        client = LDClient.get();
        client.registerStatusListener(ldStatusListener);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        client.unregisterStatusListener(ldStatusListener);
    }
}
COPY

The C++ (client-side) SDK exposes some of its internal status to let your application monitor it.

The SDK has several data source states dependent on its configuration, network connectivity, and calls explicitly setting the client offline or online.

This table describes the states:

The SDK stores a timestamp of when the data source state most recently changed. It also stores information about the last error that the data source encountered, if any.

This table describes the possible errors:

Here's how to monitor the data source state:

client.DataSourceStatus().OnDataSourceStatusChange([](client_side::data_sources::DataSourceStatus status) {
  if (status.State() ==
  client_side::data_sources::DataSourceStatus::
  DataSourceState::kValid) {
    /* Flag data has been received from LaunchDarkly.*/
  }
});
COPY

If you are working in C, there are a few more steps:

1. Define a callback to receive the data source status change:

   C++ SDK v3.0 (C binding), define callback

   void OnDataSourceStatusChanged(LDDataSourceStatus status, void* user_data) {
     printf("status: %d\n", LDDataSourceStatus_GetState(status));
   }
   COPY

2. Assign the callback by creating a listener connection:

   C++ SDK v3.0 (C binding), create listener connection

   struct LDDataSourceStatusListener listener;
   LDDataSourceStatusListener_Init(listener);
   listener.StatusChanged = OnDataSourceStatusChanged;
   /* You may optionally assign the UserData pointer, which will be passed into StatusChanged. */
   /* listener.UserData = &some_struct; */
   LDListenerConnection connection =
           LDClientSDK_DataSourceStatus_OnStatusChange(sdk, listener);
   /* You can disconnect the listener later */
   LDListenerConnection_Disconnect(connection);
   COPY

3. Ensure the connection is freed when you are done with it:

   C++ SDK v3.0 (C binding), free connection

   LDListenerConnection_Free(connection);
   COPY

Finally, if you are working in C but are still using the older v2.x SDK, the data source status interface is not available. To wait indefinitely, use a callback:

void initCallback(LDStatus status)
{
    if (status == LDStatusInitialized) {
        printf("Completed LaunchDarkly client initialization");
    }
}
LDSetClientStatusCallback(initCallback);
COPY

To learn more, read DataSourceStatus.

By default, the client requests feature flag values only once per user. This happens once at startup time, and then each time you call identify(). You can also use a persistent connection to receive flag updates whenever they occur.

Enable this behavior by setting streaming to true in the client options or calling client.setStreaming(true). LaunchDarkly pushes new values to the SDK, which updates the current feature flag state in the background, ensuring that variation() always returns the latest values.

If you want to be notified when a flag has changed, you can use an event listener for a specific flag.

Here's how:

client.on('change:flag-key-123abc', (newValue, oldValue) => {
  console.log('The flag was ' + oldValue + ' and now it is ' + newValue);
});
COPY

Alternatively, you can listen for all feature flag changes.

Here's how:

client.on('change', (allFlagChanges) => {
  Object.keys(allFlagChanges).forEach((key) => {
    console.log('Flag ' + key + ' is now ' + allFlagChanges[key]);
  });
});
COPY

Subscribing to change events automatically turns on streaming mode as well, unless you have explicitly set streaming to false.

The Flutter SDK exposes some of its internal status through APIs to let your application monitor it. This allows the application to determine how recently the internal flag cache has been updated with the most recent values, as well as diagnose potential reasons for the flag cache to be out of date.

The SDK stores a timestamp of the most recent successful and failed connections to LaunchDarkly, as well as information related to the most recent failed connection. The LDClient method getConnectionInformation() returns a structure that lets you retrieve these fields.

LDConnectionInformation connectionInfo = await LDClient.getConnectionInformation();
// The current connection state
LDConnectionState connectionState = connectionInfo.connectionState;
// Most recent successful flag cache update
DateTime? lastSuccess = connectionInfo.lastSuccessfulConnection;
// Most recent unsuccessful flag cache update attempt
DateTime? lastfailure = connectionInfo.lastFailedConnection;
// Most recent failure or null
LDFailure? ldFailure = connectionInfo.lastFailure;
COPY

To learn more about the connection status fields, read LDConnectionInformation.

The iOS SDK exposes some of its internal status through the Connection Status API to let your application monitor it. This allows the application to determine how recently the internal flag cache has been updated with the most recent values, as well as diagnosing potential reasons for the flag cache to be out of date.

The SDK has four connectivity states dependent on its configuration, application foreground state, network connectivity, and calls explicitly setting the client offline or online.

This table describes the states:

The SDK also stores a timestamp of the most recent successful and failed connections to LaunchDarkly, as well as information related to the most recent failed connection. lastKnownFlagValidity is nil if either no connection has ever been made successfully or if the SDK has an active streaming connection. It has a value if it is in polling mode and at least one poll has completed successfully, or if it is in streaming mode whenever the streaming connection closes. The LDClient.shared method getConnectionInformation() returns a structure that lets you retrieve these fields.

The ConnectionInformation class can return four different values for lastFailureReason.

This table describes the values:

You can listen to changes in ConnectionInformation.ConnectionMode in a similar manner to flag observers.

Here is an example of the API:

// Get current connection information
let connectionInformation = LDClient.get()!.getConnectionInformation()
// Setting a connection mode update observer
LDClient.get()!.observeCurrentConnectionMode(owner: self) { [weak self] connectionMode in
    // do something after ConnectionMode was updated.
}
COPY

The React Native SDK exposes some of its internal status through the Connection Status API to allow your application to monitor the SDK's status. It provides this primarily as a mechanism for the application to determine how recently the internal flag cache has been updated with the most recent values, as well as diagnose potential reasons for the flag cache to be out of date.

const connectionMode = await client.getConnectionMode();
const lastSuccessfulConnection = await client.getLastSuccessfulConnection();
const lastFailedConnection = await client.getLastFailedConnection();
const lastFailureReason = await client.getLastFailure();
COPY

To learn more about the return types, read the API documentation about LDConnectionMode and LDFailureReason.

To check the data source status:

var dataSourceStatus = client.DataSourceStatusProvider.Status;
COPY

Alternatively, you can register an event handler that will receive a new status value whenever the status changes.

Here is an example:

client.DataSourceStatusProvider.StatusChanged +=
    (sender, status) => {
        Console.WriteLine("new status is: {0}", status);
    };
COPY

To check the data source status:

dataSourceStatus := client.GetDataSourceStatusProvider().GetStatus()
COPY

Alternatively, you can monitor a channel that provides a new status value whenever the status changes:

dataStoreStatusChannel := client.GetDataStoreStatusProvider().AddStatusListener()
go func() {
    for status := range dataStoreStatusChannel {
        fmt.Println("new status is: ", status)
    }
}()
COPY

To learn more, read GetDataSourceStatusProvider and GetDataStoreStatusProvider.

To check the data source status:

DataSourceStatusProvider.Status dataSourceStatus =
  client.getDataSourceStatusProvider().getStatus()
COPY

Alternatively, you can register an event listener that receives a new status value whenever the status changes:

client.getDataSourceStatusProvider().addStatusListener(
  status -> {
    System.out.println("new status is: " + status);
  }
);
COPY

To learn more, read DataSourceStatusProvider and DataStoreStatusProvider.

To check the data source status:

status = client.data_source_status_provider.status
COPY

Alternatively, you can register an event listener that receives a new status value whenever the status changes:

# listener#update will be called when the status is changed
client.data_source_status_provider.add_listener(listener);
COPY

To learn more, read DataSource::StatusProvider and DataStore::StatusProvider.