Introduction
Onboarding
What is CloudBees Feature Management?
Use cases
Introduction
Installing client-side SDKs
Installing server-side SDKs
About feature flags
Environments
Creating a feature flag
Creating a boolean flagCreating a string flagCreating a number flagCreating a flag via Dynamic APISetting flag default values
Feature flag settings
Deleting a feature flag
Embedded feature flags
Multiplatform feature flags
Flag freeze levels
Feature flag configuration update flow
Configuration values
Toggling flags on and off
Audiences
Custom properties
Percentage rollouts
Scheduled rollouts
Target groups
Flag dependencies
About features
Creating and deleting features
Managing features
Configuration as Code
Verbose logging
Local testing
Microservices testing
User space error handler
Flag impressions
Fetched handler
Integrating with Jira
Managing users
Managing teams and permissions
Managing applications
Managing billing plans
Audit log
SAML single sign-on
Two-factor authentication
Allow/Disallow domains
Secret mode
Support policies
Supported platforms
Terms and services
Open Source Software Attributes

Creating a boolean flag

In order to create a boolean flag, you need two things:

  • A container class for your flags

  • A defined flag inside the container class

Creating a container class and defining a feature flag

In the examples below, a container class is defined along with a Boolean flag. The flag name, videoChat, is derived from the flag variable name. This flag is false by default.

Swift Objective-c Android React Native JavaScript Node.js JavaScript SSR JVM Kotlin .NET Python Go Ruby PHP C C++ 
import Foundation
import ROX
public class Flags: RoxContainer{
  public let videoChat = RoxFlag();
}
 
#import <ROXCore/ROXCore.h>

@interface Flags : ROXBaseContainer

@property (nonatomic) ROXFlag* videoChat;

@end


#import "Flags.h"

@implementation Flags

- (instancetype)init {
  self = [super init];
  if (self) {
    self.videoChat = [[ROXFlag alloc] init];
  }
  return self;
}

@end
 
public class Flags implements RoxContainer{
  public RoxFlag videoChat = new RoxFlag();
}
 
const flags = {
  videoChat: new Rox.Flag()
};
 
const flags = {
  videoChat: new Rox.Flag()
};
 
const flags = {
  videoChat: new Rox.Flag()
};
 
import {Flag} from 'rox-ssr';

const flags = {
  videoChat: new Flag()
};
 
public class Flags implements RoxContainer{
  public RoxFlag videoChat = new RoxFlag();
}
 
import kotlin.jvm.JvmField

class Flags: RoxContainer {
    @JvmField
  val videoChat = RoxFlag()
}
 
public class Flags : IRoxContainer
{
  public RoxFlag videoChat = new RoxFlag();
}
 
from rox.server.flags.rox_flag import RoxFlag

class MyContainer:
     def __init__(self):
        self.video_chat = RoxFlag()
 
import (
     "github.com/rollout/rox-go/server"
)

type Container struct {
     EnableTutorial server.RoxFlag
}

var flags = &Container {
     // Default value must be specified with go
   EnableTutorial: server.NewRoxFlag(false),
}
 
require 'rox/server/rox_server'

class Container
    attr_accessor :video_chat

  def initialize
    @video_chat = Rox::Server::RoxFlag.new
  end
end
 
use Rox\Server\Rox;
use Rox\Server\Flags\RoxFlag;
require __DIR__ . '/vendor/autoload.php';

class Container
{
    public $video_chat;

    public function __construct()
    {
        $this->video_chat = new RoxFlag(false);
    }
}
 
RoxVariant *videoChat = rox_add_flag("demo.video_chat", false);
 
Rox::Flag *videoChat = Rox::Flag::Create("demo.video_chat", false);

Registering the container class

Once you have the container class, you need to register its instance to the CloudBees Feature Management SDK. This is done with the Rox.register() SDK function.

The namespace parameter is a logical separation between containers, and can be used to find flags on the dashboard.

Important notes

  • A namespace can only be registered once.

In the examples below, the Rox.register() SDK function is called to register the class instance:

Swift Objective-C Android React Native JavaScript Node.js JavaScript SSR JVM .NET Python Go Ruby PHP C C++ 
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

  ROX.register("<namespace>", container: Flags())
  ROX.setup(withKey: ROLLOUT_KEY)
  return true
}
 
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    [ROX register:[[Flags alloc] init]];
    [ROX setupWithKey:@<ROLLOUT_KEY>];

    return YES;
}
 
public class App extends Application {

  @Override
  public void onCreate() {
    super.onCreate();

    Flags flags = new Flags();
    Rox.register("<namespace>", flags);

    Rox.setup(this);

    // This can also be done in the MainActivity if your app doesn't extends the Application class
  }
}
 
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
await Rox.setup('<ROLLOUT_KEY>');
 
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
Rox.setup('<ROLLOUT_KEY>');
 
const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
await Rox.setup('<ROLLOUT_KEY>');
 
import {Rox} from 'rox-ssr';

const flags = {
  // define Rox entities here
}
Rox.register('<namespace>', flags);
Rox.setup('<ROLLOUT_KEY>');
 
Flags flags = new Flags();
Rox.register("<namespace>", flags);
Rox.setup(ROLLOUT_KEY);
 
Container flags = new Container();
Rox.Register("<namespace>", flags);
await Rox.Setup(<ROLLOUT_KEY>);
 
from rox.server.rox_server import Rox

flags = MyContainer()
Rox.register(<namespace>, flags)
cancel_event = Rox.setup('<ROLLOUT_KEY>').result()
 
package main
import "github.com/rollout/rox-go/server"

type Container struct {
     EnableTutorial server.RoxFlag
}

var flags = &Container {
     // Default value must be specified with go
   EnableTutorial: server.NewRoxFlag(false),
}
var rox *server.Rox

func main() {
  options := server.NewRoxOptions(server.RoxOptionsBuilder {})

  rox = server.NewRox()
  rox.Register("<namespace>", flags)
    <-rox.Setup("<ROLLOUT_KEY>", options)
}
 
require 'rox/server/rox_server'

class Container
end

flags = Container.new

Rox::Server::RoxServer.register(<namespace>, flags)
Rox::Server::RoxServer.setup(<ROLLOUT_KEY>).join
 
use Rox\Server\Flags\RoxFlag;
use Rox\Server\Rox;

class Container
{
    public $video_chat;

    public function __construct()
    {
        $this->video_chat = new RoxFlag();
    }
}

$container = new Container();
Rox::register(<namespace>, $container);
Rox::setup(<ROLLOUT_KEY>);
 
#include <rollout.h>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

int main(int argc, char **argv) {
    RoxVariant *videoChat = rox_add_flag("demo.video_chat", false);
  rox_setup(DEFAULT_API_KEY, NULL);
  rox_shutdown();
}
 
#include <rollout.hpp>

#define DEFAULT_API_KEY "ROLLOUT_KEY"

int main(int argc, char **argv) {
    Rox::Flag *videoChat = Rox::Flag::Create("demo.video_chat", false);
  Rox::Setup(DEFAULT_API_KEY, NULL);
  Rox::Shutdown();
}

Using the flag

The last two things you need to do in the SDK is to use the flag. You can use the flag by checking the value of the flag.

The examples below show how the flag is used:

Swift Objective-C Android React Native JavaScript Node.js JavaScript SSR JVM .NET Python Go Ruby PHP C C++ 
flags.videoChat.enabled {
  print("VideoChat Feature is Enabled")
}
 
[myContainer.videoChat enabled:^{
  NSLog(@"VideoChat Feature is Enabled");
} disabled:^{
  // skip the tutorial
}];
 
if (flags.videoChat.isEnabled()) {
  Log.i(tag, "VideoChat Feature is Enabled");
}
 
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
 
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
 
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
 
if (flags.videoChat.isEnabled()) {
  console.log('videoChat is enabled');
}
 
if (flags.videoChat.isEnabled()) {
  Logger.info(tag, "VideoChat Feature is Enabled");
}
 
if (flags.videoChat.isEnabled() == true)
{
  // videoChat is enabled
}
 
if my_container.video_chat.is_enabled():
    print('video_chat is enabled')
 
if (flags.VideoChat.IsEnabled(nil)) {
  // start the tutorial
}
 
if container.video_chat.enabled?
  puts "video_chat is enabled"
end
 
if ($container->video_chat->isEnabled()) {
    echo 'video_chat is enabled';
}
 
RoxVariant *videoChat = rox_add_flag("demo.video_chat", false);
if (rox_flag_is_enabled(videoChat)) {
}
 
Rox::Flag *videoChat = Rox::Flag::Create("demo.video_chat", false);
if (videoChat->IsEnabled()) {
}

Default flag values

A boolean flag is false by default. To override the value, pass the desired value to the flag.

Flag freeze level

Flag freeze is available on client side SDKs by default.

  • SDK version 4.x the default is set to untilForeground

  • SDK version 5.0 or later the default is set to none

See Understanding a flag freeze for more information.
Creating a feature flag
Creating a string flag