go-server-sdk: github.com/launchdarkly/go-server-sdk/ldfiledata Index | Files

package ldfiledata

import "github.com/launchdarkly/go-server-sdk/ldfiledata"

Package ldfiledata allows the LaunchDarkly client to read feature flag data from a file.

Index

Package Files

file_data_source.go

func NewFileDataSourceFactory Uses

func NewFileDataSourceFactory(options ...FileDataSourceOption) ld.UpdateProcessorFactory

NewFileDataSourceFactory returns a function that allows the LaunchDarkly client to read feature flag data from a file or files. You must store this function in the UpdateProcessorFactory property of your client configuration before creating the client:

fileSource, err := ldfiledata.NewFileDataSourceFactory(
    ldfiledata.FilePaths("./test-data/my-flags.json"))
ldConfig := ld.DefaultConfig
ldConfig.UpdateProcessorFactory = fileSource
ldClient := ld.MakeCustomClient(mySdkKey, ldConfig, 5*time.Second)

Use FilePaths to specify any number of file paths. The files are not actually loaded until the client starts up. At that point, if any file does not exist or cannot be parsed, the FileDataSource will log an error and will not load any data.

Files may contain either JSON or YAML; if the first non-whitespace character is '{', the file is parsed as JSON, otherwise it is parsed as YAML. The file data should consist of an object with up to three properties:

- "flags": Feature flag definitions.

- "flagValues": Simplified feature flags that contain only a value.

- "segments": User segment definitions.

The format of the data in "flags" and "segments" is defined by the LaunchDarkly application and is subject to change. Rather than trying to construct these objects yourself, it is simpler to request existing flags directly from the LaunchDarkly server in JSON format, and use this output as the starting point for your file. In Linux you would do this:

curl -H "Authorization: <your sdk key>" https://app.launchdarkly.com/sdk/latest-all

The output will look something like this (but with many more properties):

{
  "flags": {
    "flag-key-1": {
      "key": "flag-key-1",
      "on": true,
      "variations": [ "a", "b" ]
    }
  },
  "segments": {
    "segment-key-1": {
      "key": "segment-key-1",
      "includes": [ "user-key-1" ]
    }
  }
}

Data in this format allows the SDK to exactly duplicate all the kinds of flag behavior supported by LaunchDarkly. However, in many cases you will not need this complexity, but will just want to set specific flag keys to specific values. For that, you can use a much simpler format:

{
  "flagValues": {
    "my-string-flag-key": "value-1",
    "my-boolean-flag-key": true,
    "my-integer-flag-key": 3
  }
}

Or, in YAML:

flagValues:
  my-string-flag-key: "value-1"
  my-boolean-flag-key: true
  my-integer-flag-key: 3

It is also possible to specify both "flags" and "flagValues", if you want some flags to have simple values and others to have complex behavior. However, it is an error to use the same flag key or segment key more than once, either in a single file or across multiple files.

If the data source encounters any error in any file-- malformed content, a missing file, or a duplicate key-- it will not load flags from any of the files.

type FileDataSourceOption Uses

type FileDataSourceOption interface {
    // contains filtered or unexported methods
}

FileDataSourceOption is the interface for optional configuration parameters that can be passed to NewFileDataSourceFactory. These include FilePaths and UseLogger.

func FilePaths Uses

func FilePaths(paths ...string) FileDataSourceOption

FilePaths creates an option for to NewFileDataSourceFactory, to specify the input data files. The paths may be any number of absolute or relative file paths.

func UseLogger Uses

func UseLogger(logger ld.Logger) FileDataSourceOption

UseLogger creates an option for NewFileDataSourceFactory, to specify where to send log output. If not specified, it defaults to using the same logging options as the rest of the SDK.

func UseReloader Uses

func UseReloader(reloaderFactory ReloaderFactory) FileDataSourceOption

UseReloader creates an option for NewFileDataSourceFactory, to specify a mechanism for reloading data files. It is normally used with the ldfilewatch package, as follows:

ldfiledata.UseReloader(ldfilewatch.WatchFiles)

type ReloaderFactory Uses

type ReloaderFactory func(paths []string, loggers ld.Logger, reload func(), closeCh <-chan struct{}) error

ReloaderFactory is a function type used with UseReloader, to specify a mechanism for detecting when data files should be reloaded. Its standard implementation is in the ldfilewatch package.

Package ldfiledata imports 10 packages (graph). Updated 2020-02-09. Refresh now. Tools for package owners.