Forem: Charlie Macnamara

Analysis of alternative Feature Flag software

Charlie Macnamara — Tue, 26 May 2020 14:03:16 +0000

With such a fast-moving software industry, competing companies aiming to provide solutions to our development needs are popping up at a faster pace, with more impressive solutions than ever before. Too often, however, we may fall victim to using the most widely adopted software instead of looking at what alternative companies have to offer where we might find something rather special.

In this article, we are going to look at alternative Feature Flag services to use instead of the market leader Feature Flag service, LaunchDarkly. Since its launch in 2013, LaunchDarkly has gained definite market control over the SaaS Feature Flag industry. While there is no doubt that LaunchDarkly is a great service, there is a plethora of alternative software from companies aiming to deliver high-quality Feature Flags, with additional advantages over LaunchDarkly, such as price, functionality, and ease of use. So With that said this article has in no means been made to bring a negative light to the service, it is more to shed light on the other services that you could use. And hey, if none of these services are for you, you can always use LaunchDarkly.

So with that, all said let's start taking a look at other alternative companies and see what they bring to the table by discussing a bit about what the company offers, their pricing, as well as a small code example of showing how to use their software. All the necessities to get you caught up. And just to make it clear, these companies are not ordered by personal preference, I'm just a fan of alphabetical ordering. :)

Appknobs

Appknobs have set themselves apart from the rest of the Feature Flag market by building a front-end, declarative feature-flag management solution that makes Appknobs the one-stop-shop for React-based developers or anyone who has the itch to flesh out their front-end projects. It's easy and intuitive for front end developers to use, and because Appknobs is declarative, they have a pretty neat flag auto-discovery tool that lets devs easily add feature tags, parse their code, and display flags in the admin panel all in a matter of seconds. However, where Appknobs falls short is by having a lack of external integrations and analytics, but this is a feature they are planning to add in the future.

pricing

Appknobs offer three package types for your ideal use case:

A free plan that allows one application and one flag feature to be created.
A Startup plan which includes unlimited flags on one application for the price of £6.00/month
Finally, they offer a Premium plan that you can try for free for 30 days. This is the ideal package they offer for agencies or larger projects at a monthly rate of £29.00 per month.

Example

As you can see in the example below, inserting Appknobs is really simple and will fit into your programs without any problems while providing a great way to use Featuring Flags.

import * as React from 'react'

import {render} from 'react-dom'

import {Appknobs, Feature} from '@appknobs/react'

import {newBrowserClient} from '@appknobs/client'

const App = ({client, stage}) => (

  <Appknobs client={client} payload={{stage}}>

      <Feature name='first-feature'>

        <p>This feature is hidden behind a toggle!</p>

      </Feature>

  </Appknobs>

)

const client = newBrowserClient({apiKey: 'YOUR_API_KEY', appId: 'YOUR_APP_ID'})

render(<App client={client} stage={'dev'} />, document.querySelector('#root'))

Available SDKs

React
React Native
Angular
Electron
Node.js (server-side)

Apptimize

What makes Apptimize stand out is its outstanding mobile first-class solution for quick and easy testing. They are the most widely used mobile A/B testing and release management solution, so if mobile is your preferred platform, this is most likely your service. Apptimize enables more stakeholders to test across the company using their visual editor for mobile devices and using "dynamic variables." Apptimize also enables goal-based results so that you can automatically pull events from third parties and see the direct business impact of your tests. They also offer a wealth of integration from third party applications

Pricing

Apptimize works their pricing in a very fairway. Instead of paying for a certain amount of features that you may not actually make full use of, you are billed from each of your monthly devices. All customers have full access to Feature Flags, A/B Experiments, and Instant Updates with no limitations on metrics, experiments, events, or seats.

Example

Implementation of Apptimize is as easy as it can be. All you need is a simple property value and installed library, then you're good to go!

if (Apptimize.isFeatureFlagOn("risky_new_feature")){

 // ON

 [show risky new feature]

} else {

 // OFF

 [hide risky new feature]

}

Available SDKs

iOS
Android
React Native (mobile)
JavaScript
Roku
Java (server)
Node.js (Server)
PHP (Server)
Python (Server)

Bullet Train

Bullet Train has built its product by combining the concepts of feature toggles with the flexibility of remote configuration, all of which are integrated into a single stellar package. They offer a great deal of flexibility by enabling management across web, mobile, and server-side applications, and if that wasn't enough, they are completely open-source, allowing you to host all of their infrastructures on your own. Since Bullet Train is open-source, this also brings extra security benefits as you can inspect the code yourself to make sure there are no back doors. I have to commend Bullet Train, as I'm a sucker for anything open source, and it's great to see that they haven't decided to focus on the extra bells and whistles of Feature Flags that some users may not use (such as A/B testing analytics) and instead put all their effort into the key features of the Feature Flags.

Pricing

While Bullet Train is completely open-source, meaning you don’t have to give them a penny if you don’t want to, they do offer some priced plans with additional benefits:

Free: Up to 20k API calls per month, 1 Team Member
$29/month: Up to 250k API calls per month, 3 Team Members
$99/month: Up to 2M API calls per month, 10 Team Members
They also offer a negotiable custom plan which you can enquire about by calling them which offers Over 2M API calls or 10 team members

Example

The code below is a great example of the flexibility you have with BulletTrain. BulletTrain allows you to code your Feature Flags to your ideal use case with almost unlimited customization.

var bulletTrain = require("bullet-train-nodejs");

bulletTrain.init({

    environmentID: "<YOUR_ENVIRONMENT_KEY>"

});

bulletTrain.hasFeature("header", '<My User Id>')

    .then((featureEnabled) => {

        if (featureEnabled) {

            //Show my awesome cool new feature to this one user

        }

    });

bulletTrain.hasFeature("header")

    .then((featureEnabled) => {

        if (featureEnabled) {

            //Show my awesome cool new feature to the world

        }

    });

available SDKs

Javascript/React/React Native
Node
Android
iOS
Java
Python
Ruby
.Net
REST

ConfigCat

ConfigCat was built with the idea of being the ideal Feature Flag service for teams. They've created a stress-free Feature Flag solution, in which they 've streamlined the process of using Feature Flags for their users so you don't have to mess around with unnecessary decisions while making sure their product is as intuitive as it's easy to set up and get started. If you choose ConfigCat as your flag feature service, you'll be up and running in 10 minutes, and if you have any issues, they have a Slack community channel that the teams devs almost immediately respond to, as well they offer a whole bunch of integration options. And if you weren't won over, they're also planting a tree for every subscription (10 trees for Unlimited Accounts!) and hey, we can't skip the fact that they have a lovely cat as their logo. Serious extra points for that in my eyes.

Pricing

ConfigCat offers an expansive, forever-free plan that includes all of the flag features that you may want to use such as segmentation, targeting, multi-factor authentication or support for SSO and more, but they do offer some very useful benefits if you decide to upgrade your flag feature game by purchasing a paid account:

Free plan: includes up to 10 Feature Flags, 1 product, and 2 environments
Professional plan: up to 100 Feature Flags, 3 products, 3 environments, and 1 tree planted all for the rate of €49/month.
Unlimited Plan: Well, this is as simple as it can be, everything they offer is unlimited! (Well, besides the trees, they plant 10 per month) at a rate of €199/month.
Dedicated plan: This gives you the same benefits as the unlimited plan, as well as the dedicated infrastructure and domain name at a rate of €1499 per month.

Example

If the 10 minute startup guide found on ConfigCat 's homepage didn't win you over with how seamless integration is, I hope the example below will work. ConfigCat delivers a secure and easy Feature Flag implementation that you won't be disappointed with.

npm i configcat-node

const configcat = require("configcat-node");

let configCatClient = configcat.createClient("<SDK-KEY>");

const isDebugModeOn = await configCatClient.getValueAsync("isDebugModeOn", false);

console.log("Value of the Feature Flag called \"isDebugModeOn\": " + isDebugModeOn);

Available SDKs

.NET
Java
Server Side Javascript, such as NodeJS or Nuxt
Front-end JavaScript, such as Vanilla, Angular or React
React-Native
Android,
iOS
PHP, the plain-old one and frameworks like Laravel too
Python
Go
Ruby

Flipt

I have already gushed a bit about my love for open-source, so it shouldn't come as a surprise that I'm a fan of Flipt. Flipt is the only service in this article that doesn't offer any pricing plans, but that doesn't mean that they don't offer a great piece of technology. Their software comes with all the flagship services you would want, such as on/off toggles, rolling out features to a percentage of customers, and advanced segmentation. While there are advantages that the service is open source, such as greater security for the reasons mentioned earlier in this article, and that anyone can contribute, there are some caveats. Support is not as fast and reliable, there are no audit logs and there is currently no support for multiple environments and user management.

Example

Flipt's setup is simplicity at its finest, Flipt is a single binary with no external dependencies by default.

import flipt "github.com/markphelps/flipt-grpc-go"

client := flipt.NewFliptClient(conn)

flag, err := client.GetFlag(context.Background(), &flipt.GetFlagRequest{

                    Key: ‘show_coupon’,

            })

available SDKs

Any language supported by GRPC can be used by generating a Flipt client
GO
Ruby
Pythib
IOS
React

Togglz

Togglz has designed a Feature Flag service for businesses, such as start-ups and medium-sized organizations. The cool thing about Togglz is that they are language, framework, and platform agnostic. Another advantage of using Togglz is how seamless it is to set up since you don't need to install any libraries. Simply call the endpoint and digest the response, then you can store the result locally if you want to, or call the endpoint. Super simple right.

Pricing

Togglz has gone with a very simple way to set their prices that could leave something to be desired. On the one hand, I like the two simple options, but I also wish they had a middle ground.

Free: This includes 10 feature toggles, 2 environments, and 10,000 API requests per month
Pro: This comes with the added benefit of allowing more traffic, more environments and unlimited feature toggles, environments, and API requests

Example

As discussed at the beginning of the Togglz section, we don't need any external libraries to get Togglz up and running. This makes integration seamless without fiddling around, which I'm sure you can appreciate.

const res = await fetch('<Togglz-API>');

const features = await res.json();

if (features.myNewThing) {

  // ...new feature code

}

available SDKs

Since Togglz is an agnostic platform, this means that Togglz does not have any SDKs out of the box, meaning that Togglz users need to write all that HTTP request logic (including caching, error handling, etc.).

Unleashed-hosted

This brings us to the last Feature Flag service that we'll be looking at, but it's by no means the least favorable. Unleash-hosted is probably the most unique Feature Flag service I have discussed in this article. They offer two versions of their service, an open-source version, and a paid enterprise version. In a way, this combines the best of both worlds. If you want, you can self-host the entire service for free, or you can purchase an enterprise version bringing extra benefits such as premium support, and security/access benefits. They offer a vast range of Activation strategies from the get-go allowing you to enable or disable your features in production.

Pricing

Unleash-hosted offers a free trial for their type of paid account, starting at $50 a month.

Example

Similar to the example I've shown for Apptimize, Unleashed-hosted is just as easy to integrate. It's a simple library and property then you're in.

if (unleash.isEnabled("AwesomeFeature")){

 // some new magic

} else {

 // old boring stuff

}

Available SDKs

Java
Node.js
SinglePage JS
Go
Eliixir
.net
Ruby
Python

And with that, this brings us to the end of our look at the alternative Feature Flag software. As you can see, all of them share some similar traits. There's not one piece of software that I would criticize for the integration process, but it's the little things that count and will inevitably lead to your decision on which piece of software to use. I hope this article has drawn some attention to the alternative Feature Flag software that you can use and has given you some valuable information regarding each company I have discussed. They're all great on their own merits, and you're not going to be disappointed by whatever choice you choose.

Comparing integration of Feature Flags: ConfigCat and LaunchDarkly

Charlie Macnamara — Wed, 06 May 2020 14:41:02 +0000

Feature flags are great. They give you a controlled way to introduce features and capabilities. It's as simple as turning on and off your change. This has undeniably saved many software engineers some heartbreak.

My name is Charlie. I'm new to feature flags and thought I would share my first-hand experience setting them up. If you are unfamiliar with using feature flags, just as I am, or are just looking for the right service, you are in the right place. Today, we are going to compare the integration process between ConfigCat and LaunchDarkly using a simple Python program.

If you want to follow along but Python isn't your language of choice, don't worry! Both companies offer many SDKs.

Let's talk about what we are going to build. For those who are familiar with ConfigCat and their feature flags section of their website, chances are you saw the isCoolCatEnabled toggle and thought "wow, if only I create something as neat", well if so, you are in luck! That's precisely what we are going to be demonstrating today. Well, sort of. We are creating a program that will import an image and invert the color when our flag is on, saving the result to a new file. And when the flag is off, our program will delete the file.

Now that you know what you're in for, let's look at integrating it on the ConfigCat side. To get started, sign in to your ConfigCat account and select Add Feature Flag, create a name (in my case I have gone with "catinvert"), then click Add Feature Flag. Yes really, it's that simple.

We need to install the ConfigCat library from here, so open your terminal and enter it.

"bash
pip install configcat-client

If you're following along with this post, you'll need another library too, so go ahead and install the `Pillow` library with:

""ash
pip install Pillow

Now that everything is installed, we can get into the fun stuff. Open your favorite IDE, create a new .py file, add an image to the same folder(I decided to go with the ConfigCat logo in the spirit of this post), and then we can get started! To implement ConfigCat, simply enter the following lines. Again, if you're following along, I import some more libraries, but this will be reflected as you read on.

My imported image

import  configcatclient
configcat_client = configcatclient.create_client_with_auto_poll( 'YOUR_SDK_KEY',poll_interval_seconds=10);
YOUR_FEATURE_FLAG = configcat_client.get_value('Y'UR_FEATURE_FLAG','False)

Our top-line imports the library we need. Our second line determines how often ConfigCat will download and store the values from your program. There are four options you can select for how ConfigCat does this, but we have gone with the poll_interval option. The final line allows you to access your feature flags and settings.

Bulb: Your SDK key and feature flag name will automatically be added. For security, please never share your SDK key. Sorry; we deleted our Feature Flag after we finished this post.

Now that we have that out of the way, let's look at the final program.

"`"thonPythont configcatclient
from PIL import Image, ImageOps
import time
import os

configcat_client = configcatclient.create_client_with_auto_poll(
'1uXXCAAgHzREa0_HhlhMIw/qLn4CgPtwEuTGys-Ropbmg', poll_interval_seconds=1); # <-- This is the actual SDK Key for your Production environment

while True:
catinvert = configcat_client.get_value('ca'invert', 'alse)
if catinvert:
im = Image.open('logo.jpg') # imports file
im_invert = ImageOps.invert(im) # inverts image
im_invert.save('inverted-logo.jpg', quality=95) # saves new file
else:
try:
os.remove('inverted-logo.jpg') # deletes created file
except os.error:
pass

time.sleep(1)
`
With everything in place, let's run the program and return to our feature flag. Turn the flag on, click save changes, and watch the magic unfold!

The program does exactly as we intended. When the flag is on, the imported image gets inverted, and the image gets deleted when off.

My result image

Let's go to LaunchDaily and implement the same program. Everything starts off similarly: select Create Flag, select a name (I went with "darkly invert"), and then create a folder and a .py file.

For LaunchDarkly to function, we need to install their SDK library, open up a terminal, and enter:
` echo "launchdarkly-server-sdk==6.13.0" >> requirements.txt && pip install -r requirements.txt `
Now let's look at what lines of code we need to implement.

"`p" hon
iPythonldclient
if name == "main":
ldclient.set_sdk_key("YOUR_SDK_KEY")
user = {
"key": ""NI" UE IDENTIFIER",
"fir"tName": ""ob",
""lastName": "Loblaw",
"cus"om": {" "gro"ps": ""et"_testers"
"
}

show_feature = ldclient.get().variation("YOUR_FEATURE_FLAG", user, False)
ldclient.get().close()
`
The top line imports the LaunchDarkly library. Our second line sets our SDK key. Next, our user information is sent in; let's stick to the default. Following that show_feature allows you to access our feature flags and settings.

💡 Your SDK key and Feature Flag are automatically added.

Once we have done all this, we can save and test. LaunchDarkly will show you in real time if they have received an event for your flag before moving on.

Now, let's alter our program. Add an image to the same folder so LaunchDarkly can get to work. Let's change our image to LaunchDarkly's logo.

My imported image

"`py" on
impPythonclient
from PIL import Image, ImageOps
import time
import os

if name == "main":
ldclient.set_sdk_key("sdk-17e098af-f9df-417b-b846-a29d65144779")

user = {
"key"" "U"IQ"E IDENTIFIER",
"firs" Name": "B"b""
"lastName": "Loblaw",
"cust"m": {
" "grou"s": "b" ta"testers"
}"}

while True:
show_feature = ldclient.get().variation("dark"yinvert", us"r, False)
if show_feature:
im = Image.open('logo.jpg') # imports file
im_invert = ImageOps.invert(im) # inverts image
im_invert.save('inverted-logo.jpg', quality=95) # saves new file
else:
try:
os.remove('inverted-logo.jpg') # deletes created file
except os.error:
pass

time.sleep(1)

ldclient.get().close()



As you can see, little has changed. The apparent difference is the user information LaunchDarkly needs. Let's start our program, head over to our new feature flag, and turn it on.
<img src="https://dev-to-uploads.s3.amazonaws.com/i/7dpvfbmes7b33ahs8v3z.png" alt="LaunchDarkly flag on"/ width="500" height="500">

The main difference between doing this on LaunchDarkly and ConfigCat is that you must enter the name of your production environment and a comment to turn on your flag.
<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/i/43fx2fcl260gra529ph1.jpg" alt="LaunchDarkly inverted image"/ width="270" height="270">
  <figcaption> My result image </figcaption>
</figure>


As expected, everything worked as intended. Now we have looked into integration on both ends, let's look at the key differences:
- ConfigCat offers four different ways off the bat to download your values, LaunchDarkly has options for this, but you'll have to delve into their [customization documentation]
(https://docs.launchdarkly.com/sdk/server-side/python#customizing-your-client) to set up some extra stuff with their parameters
- LaunchDarkly tests your connection in the startup process, prompting you to try again if the connection has failed. ConfigCat displays if your initial request was successful by displaying the 'last accessed datetime below your feature flag
- LaunchDarkly needs extra user information for your program. ConfigCat does not require this step
- Switching your flag on with ConfigCat is as simple as on-off, LaunchDarkly requires you to input some extra information

Both software ultimately aim to provide the same result when implementing feature flags—there are clear pros and cons to either. LaunchDarkly is the market leader, offering more support options and the security of using a long-standing product.

However, since you can only use your account on a trial basis, this may not be ideal for students or people just looking to try out feature flags. ConfigCat, on the other hand, has a free account type that you can use forever, with the base account type being cheaper than LaunchDarkly. And hey, a cute cat is the logo. That's me sold. Just kidding, both pieces of software are excellent in their merit.