Redis

using LaunchDarkly.Sdk.Server;
using LaunchDarkly.Sdk.Server.Integrations;
var config = Configuration.Builder(sdkKey)
    .DataStore(
        Components.PersistentDataStore(
            Redis.DataStore()
                .HostAndPort("my-redis", 6379)
                .Prefix("my-key-prefix")
        ).CacheSeconds(30)
    )
    .Build();
var client = new LDClient(config);
COPY

// Make sure to include the redis source's header.
#include <launchdarkly/server_side/integrations/redis/redis_source.hpp>
using namespace launchdarkly::server_side;
using LazyLoad = config::builders::LazyLoadBuilder;
ConfigBuilder config_builder(sdk_key);
auto redis_source = integrations::RedisDataSource::Create("redis://localhost:6379", "my-key-prefix");
if (!redis_source) {
    /* redis config is invalid, cannot proceed */
}
config_builder.DataSystem().Method(
    LazyLoad().Source(*redis_source).CacheRefresh(std::chrono::seconds(15))
);
auto config = config_builder.Build();
if (!config) {
    /* an error occurred, config is not valid */
}
COPY

LdOptions = #{
  redis_host     => "redis",
  redis_port     => "6379",
  redis_prefix   => "default",
  feature_store  => ldclient_storage_redis,
  cache_ttl      => 15
},
ldclient:start_instance("sdk-key-123abc", LdOptions).
COPY

import (
    "time"
    ld "github.com/launchdarkly/go-server-sdk/v6"
    "github.com/launchdarkly/go-server-sdk/v6/ldcomponents"
    ldredis "github.com/launchdarkly/go-server-sdk-redis"
)
var config ld.Config
config.DataStore = ldcomponents.PersistentDataStore(
    ldredis.DataStore().
        HostAndPort("my-redis", 6379).
        Prefix("my-key-prefix"),
).CacheSeconds(30)
client, _ := ld.MakeCustomClient(sdkKey, config, 5*time.Second)
COPY

import qualified Database.Redis as               R
import           LaunchDarkly.Server
import           LaunchDarkly.Server.Store.Redis
main = do
    con <- R.checkedConnect R.defaultConnectInfo { R.connectHost = "my-redis:6379" }
    backend <- makeRedisStore $ redisConfigSetNamespace "my-key-prefix" $ makeRedisStoreConfig con
    let config = configSetStoreBackend backend $ makeConfig "sdk-key-123abc"
    client <- makeClient config
COPY

import com.launchdarkly.sdk.server.*;
import com.launchdarkly.sdk.server.integrations.*;
LDConfig config = new LDConfig.Builder()
  .dataStore(
    Components.persistentDataStore(
      Redis.dataStore().uri(URI.create("redis://my-redis:6379"))
        .prefix("my-key-prefix")
    ).cacheSeconds(30)
  )
  .build();
LDClient client = new LDClient(sdkKey, config);
COPY

local l = require("launchdarkly_server_sdk")
local r = require("launchdarkly_server_sdk_redis")
local redis = r.makeRedisSource("redis://localhost:6379", "your-key-prefix")
local config = {
    dataSystem = {
        lazyLoad = {
            source = redis
        }
    }
}
local c = l.clientInit("sdk-key-123abc", 1000, config)
COPY

const ld = require('@launchdarkly/node-server-sdk');
const RedisFeatureStore = require('@launchdarkly/node-server-sdk-redis');
const store = RedisFeatureStore({
    redisOpts: { host: 'redis-host', port: 6379 },
    prefix: 'your-key-prefix',
    cacheTTL: 30,
});
const options = {
  featureStore: store
};
const client = ld.init(sdkKey, options);
COPY

$fr = LaunchDarkly\Integrations\Redis::featureRequester([
    'redis_host' => 'my-redis',
    'redis_port' => 6379,
    'redis_prefix' => 'my-key-prefix'
]);
$client = new LaunchDarkly\LDClient("sdk-key-123abc", [
    'feature_requester' => $fr
]);
COPY

$fr = LaunchDarkly\Integrations\PHPRedis::featureRequester([
    'redis_host' => 'my-redis',
    'redis_port' => 6379,
    'redis_prefix' => 'my-key-prefix'
]);
$client = new LaunchDarkly\LDClient("sdk-key-123abc", [
    'feature_requester' => $fr
]);
COPY

import ldclient
from ldclient.config import Config
from ldclient.feature_store import CacheConfig
from ldclient.integrations import Redis
store = Redis.new_feature_store(url='redis://my-redis:6379',
    prefix='my-key-prefix', caching=CacheConfig(expiration=30))
# Prior to version 6.7.0, use this syntax:
# store = RedisFeatureStore(url='redis://my-redis:6379', prefix='my-key-prefix',
#     expiration=30)
config = Config(feature_store=store)
ldclient.set_config(config)
COPY

require 'ldclient-rb'
store = LaunchDarkly::Integrations::Redis.new_feature_store(
  redis_url: 'redis://my-redis:6379',
  prefix: 'my-key-prefix',
  expiration: 30
)
# Prior to version 5.5.0, use "LaunchDarkly::RedisFeatureStore.new" instead
# of "LaunchDarkly::Integrations::Redis.new_feature_store"
config = LaunchDarkly::Config.new(
  feature_store: store
)
client = LaunchDarkly::Client.new(sdk_key, config)
COPY