Redis

1
using LaunchDarkly.Sdk.Server;
2
using LaunchDarkly.Sdk.Server.Integrations;
3
var config = Configuration.Builder(sdkKey)
4
    .DataStore(
5
        Components.PersistentDataStore(
6
            Redis.DataStore()
7
                .HostAndPort("my-redis", 6379)
8
                .Prefix("my-key-prefix")
9
        ).CacheSeconds(30)
10
    )
11
    .Build();
12
var client = new LDClient(config);

1
// Make sure to include the redis source's header.
2
#include <launchdarkly/server_side/integrations/redis/redis_source.hpp>
3
4
using namespace launchdarkly::server_side;
5
6
using LazyLoad = config::builders::LazyLoadBuilder;
7
8
ConfigBuilder config_builder(sdk_key);
9
10
auto redis_source = integrations::RedisDataSource::Create("redis://localhost:6379", "my-key-prefix");
11
12
if (!redis_source) {
13
    /* redis config is invalid, cannot proceed */
14
}
15
16
config_builder.DataSystem().Method(
17
    LazyLoad().Source(*redis_source).CacheRefresh(std::chrono::seconds(15))
18
);
19
20
auto config = config_builder.Build();
21
if (!config) {
22
    /* an error occurred, config is not valid */
23
}

1
LdOptions = #{
2
  redis_host     => "redis",
3
  redis_port     => "6379",
4
  redis_prefix   => "default",
5
  feature_store  => ldclient_storage_redis,
6
  cache_ttl      => 15
7
},
8
ldclient:start_instance("sdk-key-123abc", LdOptions).

1
import (
2
    "time"
3
4
    ld "github.com/launchdarkly/go-server-sdk/v6"
5
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
6
    ldredis "github.com/launchdarkly/go-server-sdk-redis-redigo"
7
)
8
9
var config ld.Config
10
config.DataStore = ldcomponents.PersistentDataStore(
11
    ldredis.DataStore().
12
        HostAndPort("my-redis", 6379).
13
        Prefix("my-key-prefix"),
14
).CacheSeconds(30)
15
client, _ := ld.MakeCustomClient(sdkKey, config, 5*time.Second)

1
import qualified Database.Redis as               R
2
import           LaunchDarkly.Server
3
import           LaunchDarkly.Server.Store.Redis
4
5
main = do
6
    con <- R.checkedConnect R.defaultConnectInfo { R.connectHost = "my-redis:6379" }
7
    backend <- makeRedisStore $ redisConfigSetNamespace "my-key-prefix" $ makeRedisStoreConfig con
8
9
    let config = configSetStoreBackend backend $ makeConfig "sdk-key-123abc"
10
11
    client <- makeClient config

1
import com.launchdarkly.sdk.server.*;
2
import com.launchdarkly.sdk.server.integrations.*;
3
4
LDConfig config = new LDConfig.Builder()
5
  .dataStore(
6
    Components.persistentDataStore(
7
      Redis.dataStore().uri(URI.create("redis://my-redis:6379"))
8
        .prefix("my-key-prefix")
9
    ).cacheSeconds(30)
10
  )
11
  .build();
12
LDClient client = new LDClient(sdkKey, config);

1
local l = require("launchdarkly_server_sdk")
2
local r = require("launchdarkly_server_sdk_redis")
3
4
local redis = r.makeRedisSource("redis://localhost:6379", "your-key-prefix")
5
local config = {
6
    dataSystem = {
7
        lazyLoad = {
8
            source = redis
9
        }
10
    }
11
}
12
13
local c = l.clientInit("sdk-key-123abc", 1000, config)

1
const ld = require('@launchdarkly/node-server-sdk');
2
const RedisFeatureStore = require('@launchdarkly/node-server-sdk-redis');
3
4
const store = RedisFeatureStore({
5
    redisOpts: { host: 'redis-host', port: 6379 },
6
    prefix: 'your-key-prefix',
7
    cacheTTL: 30,
8
});
9
10
const options = {
11
  featureStore: store
12
};
13
const client = ld.init(sdkKey, options);

1
$redisClient = new Predis\Client([
2
    'host' => 'my-redis',
3
    'port' => 6379
4
]);
5
6
$fr = LaunchDarkly\Integrations\Redis::featureRequester($redisClient, ['prefix' => 'my-key-prefix']);
7
$client = new LaunchDarkly\LDClient("sdk-key-123abc", [
8
    'feature_requester' => $fr
9
]);

1
$fr = LaunchDarkly\Integrations\PHPRedis::featureRequester([
2
    'redis_host' => 'my-redis',
3
    'redis_port' => 6379,
4
    'redis_prefix' => 'my-key-prefix'
5
]);
6
$client = new LaunchDarkly\LDClient("sdk-key-123abc", [
7
    'feature_requester' => $fr
8
]);

1
import ldclient
2
from ldclient.config import Config
3
from ldclient.feature_store import CacheConfig
4
from ldclient.integrations import Redis
5
6
store = Redis.new_feature_store(url='redis://my-redis:6379',
7
    prefix='my-key-prefix', caching=CacheConfig(expiration=30))
8
9
# Prior to version 6.7.0, use this syntax:
10
# store = RedisFeatureStore(url='redis://my-redis:6379', prefix='my-key-prefix',
11
#     expiration=30)
12
13
config = Config(feature_store=store)
14
ldclient.set_config(config)

1
require 'ldclient-rb'
2
3
store = LaunchDarkly::Integrations::Redis.new_feature_store(
4
  redis_url: 'redis://my-redis:6379',
5
  prefix: 'my-key-prefix',
6
  expiration: 30
7
)
8
9
# Prior to version 5.5.0, use "LaunchDarkly::RedisFeatureStore.new" instead
10
# of "LaunchDarkly::Integrations::Redis.new_feature_store"
11
12
config = LaunchDarkly::Config.new(
13
  feature_store: store
14
)
15
client = LaunchDarkly::Client.new(sdk_key, config)