Electron SDK reference

Overview

This topic documents how to get started with the LaunchDarkly SDK for the Electron desktop application framework, and links to reference information on all of the supported features. This is a variant of the client-side JavaScript SDK with additional functionality for Electron.

The sample code snippets for this SDK are available in both JavaScript and TypeScript, where the sample code differs. To learn more, read Using LaunchDarkly with TypeScript.

Why use this instead of the Node.js SDK?

Because Electron is based on Node.js, it is possible to run the LaunchDarkly server-side Node.js SDK in it. However, we strongly discourage this because the server-side Node.js SDK is not meant for applications that are distributed to users. There are several reasons why this distinction matters:

• The server-side SDKs include an SDK key that can download the entire definition, including rollout rules and individual user targets, of all of your feature flags. If you embed this SDK key in an application, any user who looks inside the application can then access all of your feature flag definitions, which may include sensitive data such as other users' email addresses. The client-side and mobile SDKs use different credentials that do not allow this.
• The server-side SDKs download your entire flag data using this key, because they have to be able to evaluate flags quickly for any user. This can be a large amount of data. The client-side and mobile SDKs, which normally evaluate flags for just one user at a time, use a much more efficient protocol where they request only the active variation for each flag for that specific user.

LaunchDarkly also provides a client-side Node.js SDK. However, we still recommend the Electron SDK if you are working in Electron. The Electron SDK includes features that are specific to Electron, such as the ability to access main-process flags from the front end as described below.

Server-side Node.js SDK compatibility

For developers who were using the server-side Node.js in Electron before the Electron SDK was available, there are differences between the APIs that can be inconvenient. For instance, in the server-side Node.js SDK, variation() is an asynchronous call that takes a callback, whereas in the client-side SDKs it is synchronous.

To make this transition easier, the LaunchDarkly Electron SDK provides an optional wrapper that emulates the Node.js SDK. When you create the main-process client, after you call initializeInMain, pass the client object to createNodeSdkAdapter. The resulting object uses the Node-style API.

Here's how to create the wrapper:

const realClient = LDElectron.initializeInMain('client-side-id-123abc', user, options)
const wrappedClient = LDElectron.createNodeSdkAdapter(realClient)
wrappedClient.waitForInitialization().then(function () {
  wrappedClient.variation(flagKey, user, defaultValue, function (err, result) {
    console.log('flag value is ' + result)
  })
})
COPY

The underlying implementation is still the client-side SDK, which has a single-current-user model. Therefore, when you call client.variation(flagKey, user, defaultValue) it is really calling client.identify(user) first, obtaining flag values for that user, and then evaluating the flag. This performs poorly if you attempt to evaluate flags for a variety of different users in rapid succession.

Getting started

After you complete the Getting started process, follow these instructions to start using the LaunchDarkly SDK in your Electron code.

You can install the SDK into your Electron project using npm:

npm install launchdarkly-electron-client-sdk
# In earlier versions, the package name was ldclient-electron
COPY

Initializing the client

Every Electron application consists of a main process, which is similar to a Node.js application, and some number of renderer processes, each of which is a Chromium web browser with its own window. These processes have their own independent JavaScript engines and data spaces, although there are ways to communicate between them.

We designed the LaunchDarkly Electron SDK to use LaunchDarkly feature flags from within any of these processes. In the normal use case, there is an SDK client running in the main process and the renderer processes can then create client instances that are in effect mirrors of the main one.

To set up the main process client, you need the client-side ID for your LaunchDarkly environment, an object containing user properties, and optional configuration properties. You can change the user later if needed. The client-side ID authorizes your application to connect to a particular environment within LaunchDarkly.

To initialize the client:

const LDElectron = require('launchdarkly-electron-client-sdk')
const user = { key: 'example' }
const options = {}
const client = LDElectron.initializeInMain('client-side-id-123abc', user, options)
COPY

To create a client object that uses the same feature flag data in a renderer process, use this:

const LDElectron = require('launchdarkly-electron-client-sdk')
const client = LDElectron.initializeInRenderer()
COPY

This gives you an object with the same interface so you can do things like evaluate feature flags, listen for flag change events, and so on in the same way for both the main process and the renderer process. However, only the main-process client is actually communicating with LaunchDarkly. The renderer-process clients are delegating to the main-process client. This means that the overhead per application window is minimal, although you should retain a single client instance per window, rather than creating them ad-hoc when you need to evaluate a flag.

The SDK initializes both types of client asynchronously, so if you want to determine when the client is ready to evaluate feature flags, use the ready event or waitForInitialization():

// Using an event listener:
client.on('ready', function () {
  // Now we can evaluate some feature flags
})
// Or, using a Promise:
client.waitForInitialization().then(function () {
  // Now we can evaluate some feature flags
})
COPY

If you try to evaluate feature flags before the client is ready, it will behave as it would if no flags existed. For example,variation will return the fallback value.

Shut down the client

Shut down the client when your application terminates. To learn more, read Shutting down.

Supported features

This SDK supports the following features:

• Aliasing users
• Anonymous contexts and users
• Bootstrapping
• Configuration
• Evaluating flags
• Getting all flags
• Identifying and changing contexts
• Logging configuration
• Monitoring SDK status
• Private attributes
• Relay Proxy configuration, using proxy mode
• Sending custom events
• Service endpoint configuration
• Shutting down
• Subscribing to flag changes
• User and context configuration