Migrations

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call Read or Write. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

LDContext context = Context.Builder("context-key-123abc")
    .Build();
// this is the migration stage to use if the flag's migration stage
// is not available from LaunchDarkly
var defaultStage = MigrationStage.Off
var readResult = migration.Read("migration-flag-key-123abc", context, defaultStage, payload);
var writeResult = migration.Write("migration-flag-key-123abc", context, defaultStage, payload);
COPY

To learn more, read Read and Write.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

LDContext context = Context.Builder("context-key-123abc")
    .Build();
var (stage, tracker) = client.MigrationVariation("migration-flag-key-123abc", context, MigrationStage.Off);
COPY

// define the combination of reads and writes from the new and old systems
// that should occur at each migration stage
switch (stage)
    {
        case MigrationStage.Off:
        case MigrationStage.DualWrite:
        case MigrationStage.Shadow:
        case MigrationStage.Live:
        case MigrationStage.RampDown:
        case MigrationStage.Complete:
        default:
            // throw an error
    }
COPY

client.TrackMigration(tracker);
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call Read or Write. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

context := ldcontext.New("context-key-123abc")
// this is the migration stage to use if the flag's migration stage
// is not available from LaunchDarkly
defaultStage := ldmigration.Off
readResult := migrator.Read("migration-flag-key-123abc", context, defaultStage, nil)
writeResult := migrator.Write("migration-flag-key-123abc", context, defaultStage, nil)
COPY

To learn more, read Read and Write.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

context := ldcontext.New("context-key-123abc")
stage, tracker, err := client.MigrationVariation("migration-flag-key-123abc", context, ldmigration.Off)
COPY

// define the combination of reads and writes from the new and old systems
// that should occur at each migration stage
switch stage {
  case ldmigration.Off:
  case ldmigration.DualWrite:
  case ldmigration.Shadow:
  case ldmigration.Live:
  case ldmigration.RampDown:
  case ldmigration.Complete:
  default: {
    // throw an error
  }
}
COPY

event, _ := tracker.Build();
err := client.TrackMigrationOp(*event);
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call read or write. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

LDContext context = LDContext.builder("context-key-123abc")
  .build();
// this is the migration stage to use if the flag's migration stage
// is not available from LaunchDarkly
MigrationStage defaultStage = MigrationStage.OFF
Migration.MigrationResult<String> readResult = migration.read("migration-flag-key-123abc", context, defaultStage);
Migration.MigrationWriteResult<String> writeResult = migration.write("migration-flag-key-123abc", context, defaultStage);
COPY

To learn more, read Migration.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

LDContext context = LDContext.builder("context-key-123abc")
  .build();
MigrationVariation migrationVariation = client.migrationVariation("migration-flag-key-123abc", context, MigrationStage.OFF);
COPY

// define the combination of reads and writes from the new and old systems
// that should occur at each migration stage
switch (migrationVariation.getStage()) {
  case OFF:
  case DUAL_WRITE:
  case SHADOW:
  case LIVE:
  case RAMP_DOWN:
  case COMPLETE:
  default: {
    // throw an error
  }
}
COPY

MigrationOpTracker tracker = migrationVariation.getTracker();
client.trackMigration(tracker);
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call the read or write methods from the LDMigration interface. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

const ld = require('@launchdarkly/node-server-sdk');
const context: ld.LDContext = {
   kind: 'user',
   key: 'user-key-123abc',
   name: 'Sandy',
};
// this is the migration stage to use if the flag's migration stage
// is not available from LaunchDarkly
let defaultStage: ld.LDMigrationStage = LDMigrationStage.Off;
const migration = ld.createMigration(client, options);
// when you need to perform a read in your application
migration.read(
  'migration-flag-key-123abc',
  context,
  defaultStage
);
// when you need to perform a write in your application
migration.write(
  'migration-flag-key-123abc',
  context,
  defaultStage
);
COPY

To learn more, read LDMigration.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

const ld = require('@launchdarkly/node-server-sdk');
  const context: ld.LDContext = {
     kind: 'user',
     key: 'user-key-123abc',
     name: 'Sandy',
  };
  const { value, tracker } = await client.migrationVariation(
    'migration-flag-key-123abc',
    context,
    false
  );
COPY

// define the combination of reads and writes from the new and old systems
// that should occur at each migration stage
switch (value) {
  case LDMigrationStage.Off: { },
  case LDMigrationStage.DualWrite: { },
  case LDMigrationStage.Shadow: { },
  case LDMigrationStage.Live: { },
  case LDMigrationStage.RampDown: { },
  case LDMigrationStage.Complete: { },
  default: {
    // throw an error
  }
}
COPY

const event = tracker.createEvent();
if (event) {
  client.trackMigration(event);
}
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call the read or write methods from the Migrator interface. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

$context = LaunchDarkly\LDContext::builder("context-key-123abc")->build();
// this is the migration stage to use if the flag's migration stage
// is not available from LaunchDarkly
$defaultStage = Migrations\Stage::OFF;
$result = $builder->build();
if (!$result->isSuccessful()) {
    throw new \Exception($result->error);
}
$migrator = $result->value;
// if you need to pass additional information from the call site
// to your read/write methods, use a mixed type payload
$payload = ['index' => 'useful information'];
// when you need to perform a read in your application
$migrator->read('migration-flag-key-123abc', $context, $defaultStage, $payload);
// when you need to perform a write in your application
$migrator->write('migration-flag-key-123abc', $context, $defaultStage, $payload);
COPY

To learn more, read Migrator.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

$context = LaunchDarkly\LDContext::builder("context-key-123abc")->build();
$result = $client->migrationVariation('migration-flag-key-123abc', $context, Migrations\Stage::OFF);
/** @var Migrations\Stage */
$stage = $result['stage'];
/** @var Migrations\OpTracker */
$tracker = $result['tracker'];
COPY

// define the combination of reads and writes from the new and old systems
// that should occur at each migration stage
switch ($stage) {
  case Migrations\Stage::OFF:
  case Migrations\Stage::DUALWRITE:
  case Migrations\Stage::SHADOW:
  case Migrations\Stage::LIVE:
  case Migrations\Stage::RAMPDOWN:
  case Migrations\Stage::COMPLETE:
  default:
    // throw an error
}
COPY

$client->trackMigrationOperation($tracker);
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call the read or write methods from the Migrator interface. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

from ldclient import Stage
context = Context.builder("context-key-123abc").build()
# this is the migration stage to use if the flag's migration stage
# is not available from LaunchDarkly
default_stage = Stage.OFF
migrator = builder.build()
# when you need to perform a read in your application
migrator.read(
    'migration-flag-key-123abc',
    context,
    default_stage
)
# when you need to perform a write in your application
migrator.write(
    'migration-flag-key-123abc',
    context,
    default_stage
)
COPY

To learn more, read ldclient.migrations.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

context = Context.builder("context-key-123abc").build()
stage, tracker = ldclient.get().migration_variation('migration-flag-key-123abc', context, Stage.OFF)
COPY

# define the combination of reads and writes from the new and old systems
# that should occur at each migration stage
if stage == Stage.OFF:
elif stage == Stage.DUALWRITE:
elif stage == Stage.SHADOW:
elif stage == Stage.LIVE:
elif stage == Stage.RAMPDOWN:
elif stage == Stage.COMPLETE:
else:
  # throw an error
COPY

ldclient.get().track_migration_op(tracker)
COPY

To manage your migration, first you need to define how to read from and write to the old and new systems, how to check whether two reads are a match, and whether to track errors and latency metrics. To learn more, read Migration configuration.

Then, whenever you need to perform a read or write in the systems that you are modernizing or migrating, call read or write. The SDK evaluates the flag, determines which migration stage the flag is in, and performs the reads or writes in the appropriate system.

Here's how:

context = LaunchDarkly::LDContext.create({key: "user-key-123abc", kind:"user"})
# this is the migration stage to use if the flag's migration stage
# is not available from LaunchDarkly
default_stage = LaunchDarkly::Migrations::STAGE_OFF
read_result = migrator.read("migration-flag-key-123abc", context, default_stage, payload)
write_result = migration.write("migration-flag-key-123abc", context, default_stage, payload)
COPY

To learn more, read read and write.

You can check for consistency, errors, or latency under "Migration insights" on the Targeting tab of your migration flag in the LaunchDarkly user interface. To learn more, read Migration flags.

context = LaunchDarkly::LDContext.create({key: "user-key-123abc", kind:"user"})
stage, tracker = client.migration_variation(
  "migration-flag-key-123abc",
  context,
  LaunchDarkly::Migrations::STAGE_OFF
)
COPY

# define the combination of reads and writes from the new and old systems
# that should occur at each migration stage
case stage
when LaunchDarkly::Migrations::STAGE_OFF
when LaunchDarkly::Migrations::STAGE_DUALWRITE
when LaunchDarkly::Migrations::STAGE_SHADOW
when LaunchDarkly::Migrations::STAGE_LIVE
when LaunchDarkly::Migrations::STAGE_RAMPDOWN
when LaunchDarkly::Migrations::STAGE_COMPLETE
else
  # throw an error
end
COPY

client.track_migration_op(tracker);
COPY