molasses 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 65c1760e6753f23f0b5029971c67d0bd637ec58abe376d8a1a4f151eaa05bb3c
+  data.tar.gz: d1c94afb5eb0be2190b7898599375aa9395a0b986d0c3281e497b9243dfed927
+SHA512:
+  metadata.gz: 88459445d1b41d504aba89102b05d602587fde046c79a92c305e80097da3601c97fae412c8c2f394a68324aaacc887ce43cd9b5361e0b4d6f93466f1cf917b2d
+  data.tar.gz: 364dbb84b69da102d920599d2de04a4371a1e6935b9f8968bc2126b669a25b05294b5db4748f65f28650ad1307717732c4b699ced27ab41a86b7f7f9018f2ef7

data/README.md

@@ -0,0 +1,99 @@
+<p align="center">
+<img src="https://raw.githubusercontent.com/molassesapp/molasses-go/main/logo.png" style="margin: 0px auto;" width="200"/></p>
+
+<h1 align="center">Molasses-Ruby</h1>
+
+A Ruby SDK for Molasses. It allows you to evaluate user's status for a feature. It also helps simplify logging events for A/B testing.
+
+Molasses uses polling to check if you have updated features. Once initialized, it takes microseconds to evaluate if a user is active.
+
+## Install
+
+```
+gem install molasses
+
+bundle add molasses
+```
+
+## Usage
+
+### Initialization
+
+Start by initializing the client with an `APIKey`. This begins the polling for any feature updates. The updates happen every 15 seconds.
+
+```ruby
+require 'molasses'
+
+client = Molasses::Client.new("test_api_key")
+
+```
+
+If you decide not to track analytics events (experiment started, experiment success) you can turn them off by setting the `send_events` field to `false`
+
+```go
+client = Molasses::Client.new("test_api_key", false)
+
+```
+
+### Check if feature is active
+
+You can call `is_active` with the key name and optionally a user's information. The `id` field is used to determine whether a user is part of a percentage of users. If you have other constraints based on user params you can pass those in the `params` field.
+
+```ruby
+ client.is_active("FOO_TEST", {
+   "id"=>"foo",
+   "params"=>{
+     "isBetaUser"=>"false",
+     "isScaredUser"=>"false"
+    }
+ })
+
+```
+
+You can check if a feature is active for a user who is anonymous by just calling `isActive` with the key. You won't be able to do percentage roll outs or track that user's behavior.
+
+```ruby
+client.is_active("TEST_FEATURE_FOR_USER")
+```
+
+### Experiments
+
+To track whether an experiment was successful you can call `experiment_success`. experiment_success takes the feature's name, any additional parameters for the event and the user.
+
+```ruby
+client.experiment_success("GOOGLE_SSO",{
+		"version": "v2.3.0"
+	},{
+   "id"=>"foo",
+   "params"=>{
+     "isBetaUser"=>"false",
+     "isScaredUser"=>"false"
+    }
+ })
+```
+
+## Example
+
+```ruby
+require 'molasses'
+
+client = Molasses::Client.new("test_api_key")
+
+if client.is_active('NEW_CHECKOUT') {
+  puts "we are a go"
+else
+  puts "we are a no go"
+end
+foo_test = client.is_active("FOO_TEST", {
+  "id"=>"foo",
+  "params"=>{
+    "isBetaUser"=>"false",
+    "isScaredUser"=>"false"
+  }
+})
+if foo_test
+  puts "we are a go"
+else
+  puts "we are a no go"
+end
+```

data/lib/molasses.rb

@@ -0,0 +1,182 @@
+require 'workers'
+require 'faraday'
+require 'json'
+require 'zlib'
+module Molasses
+  class Client
+    def initialize(api_key, send_events=true, base_url="")
+      @api_key = api_key
+      @send_events = send_events
+      if base_url != ""
+        @base_url = base_url
+      else
+        @base_url = 'https://us-central1-molasses-36bff.cloudfunctions.net'
+      end
+      @conn = Faraday.new(
+        url: @base_url,
+        headers: {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@api_key}"
+        }
+      )
+      @feature_cache = {}
+      @initialized = {}
+      fetch_features
+      @timer = Workers::PeriodicTimer.new(15) do
+        fetch_features
+      end
+    end
+
+    def is_active(key, user={})
+      unless @initialized
+        return false
+      end
+
+      if @feature_cache.include?(key)
+        feature = @feature_cache[key]
+        result = user_active(feature, user)
+        if @send_events && user && user.include?("id")
+          send_event({
+            "event"=> "experiment_started",
+            "tags"=> user["params"],
+            "userId"=> user["id"],
+            "featureId"=> feature["id"],
+            "featureName"=> key,
+            "testType"=> result ? "experiment" : "control"
+          })
+        end
+        return result
+      else
+        return false
+      end
+    end
+
+    private
+
+    def user_active(feature, user)
+      unless feature.include?("active")
+        return false
+      end
+
+      unless user && user.include?("id")
+          return true
+      end
+
+      segment_map = {}
+      for feature_segment in feature["segments"]
+          segment_type = feature_segment["segmentType"]
+          segment_map[segment_type] = feature_segment
+      end
+
+      if segment_map.include?("alwaysControl") and in_segment(user, segment_map["alwaysControl"])
+        return false
+      end
+      if segment_map.include?("alwaysExperiment") and in_segment(user, segment_map["alwaysExperiment"])
+        return true
+      end
+
+      return user_percentage(user["id"], segment_map["everyoneElse"]["percentage"])
+    end
+
+    def user_percentage(id="", percentage = 0)
+      if percentage == 100
+        return true
+      end
+
+      if percentage == 0
+        return false
+      end
+
+      c = Zlib.crc32(id)
+      v = (c % 100).abs
+      return v < percentage
+    end
+
+    def in_segment(user, segment_map)
+      user_constraints = segment_map["userConstraints"]
+      constraints_length = user_constraints.length
+      constraints_to_be_met = segment_map["constraint"] == 'any' ? 1 : constraints_length
+      constraints_met = 0
+
+      for constraint in user_constraints
+        param = constraint["userParam"]
+        param_exists = user["params"].include?(param)
+        user_value = nil
+        if param_exists
+          user_value = user["params"][param]
+        end
+
+        if param == "id"
+          param_exists = true
+          user_value = user["id"]
+        end
+
+        if meets_constraint(user_value, param_exists, constraint)
+          constraints_met = constraints_met + 1
+        end
+      end
+      return constraints_met >= constraints_to_be_met
+    end
+
+    def meets_constraint(user_value, param_exists, constraint)
+      operator = constraint["operator"]
+      if param_exists == false
+        return false
+      end
+
+      case operator
+      when "in"
+        list_values = constraint["values"].split(',')
+        return list_values.include? user_value
+      when "nin"
+        list_values = constraint["values"].split(',')
+        return !list_values.include?(user_value)
+      when "equals"
+        return user_value == constraint["values"]
+      when "doesNotEqual"
+        return user_value != constraint["values"]
+      when "contains"
+        return constraint["values"].include?(user_value)
+      when "doesNotContain"
+        return !constraint["values"].include?(user_value)
+      else
+        return false
+      end
+    end
+    def experiment_success(key, additional_details={}, user=nil)
+      if !@initialized || !@send_events || user == nil || user.include?("id")
+          return false
+      end
+      feature = @feature_cache[key]
+      result = is_active(feature, user)
+      send_event({
+          "event"=> "experiment_success",
+          "tags"=> user["params"].merge(additional_details),
+          "userId"=> user["id"],
+          "featureId"=> feature["id"],
+          "featureName"=> key,
+          "testType"=> result ? "experiment" : "control"
+      })
+    end
+    def send_event(event_options)
+      @conn.post('analytics', event_options.to_json)
+    end
+
+    def fetch_features()
+      response = @conn.get('get-features')
+      if response.status == 200
+        data = JSON.parse(response.body)
+        if data.include?("data") and data["data"].include?("features")
+          features = data["data"]["features"]
+          for feature in features do
+            @feature_cache[feature["key"]] = feature
+          end
+          @initialized = true
+        end
+      else
+        puts "Molasses - #{response.status} - #{response.body}"
+      end
+    end
+
+  end
+end

data/spec/molasses_spec.rb

@@ -0,0 +1,279 @@
+require 'faraday'
+require 'molasses'
+require 'webmock/rspec'
+responseA = {
+  "data": {
+      "features": [
+          {
+              "active": true,
+              "description": "foo",
+              "key": "FOO_TEST",
+              "segments": [
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "alwaysControl",
+                      "userConstraints": [
+                          {
+                              "userParam": "isScaredUser",
+                              "operator": "in",
+                              "values": "true,maybe",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "alwaysExperiment",
+                      "userConstraints": [
+                          {
+                              "userParam": "isBetaUser",
+                              "operator": "equals",
+                              "values": "true",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "everyoneElse",
+                      "userConstraints": [],
+                  },
+              ],
+          },
+      ],
+  }, }
+responseB = {
+  "data": {
+      "features": [
+          {
+              "id": "1",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_TEST",
+              "segments": [
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "alwaysControl",
+                      "userConstraints": [
+                          {
+                              "userParam": "isScaredUser",
+                              "operator": "nin",
+                              "values": "false,maybe",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "alwaysExperiment",
+                      "userConstraints": [
+                          {
+                              "userParam": "isBetaUser",
+                              "operator": "doesNotEqual",
+                              "values": "false",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "everyoneElse",
+                      "userConstraints": [],
+                  },
+              ],
+          },
+      ],
+  },
+}
+
+responseC = {
+  "data": {
+      "features": [
+          {
+              "id": "1",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_TEST",
+              "segments": [
+                  {
+                      "percentage": 100,
+                      "segmentType": "alwaysControl",
+                      "constraint": "all",
+                      "userConstraints": [
+                          {
+                              "userParam": "isScaredUser",
+                              "operator": "contains",
+                              "values": "scared",
+                          },
+                          {
+                              "userParam": "isDefinitelyScaredUser",
+                              "operator": "contains",
+                              "values": "scared",
+                          },
+                          {
+                              "userParam": "isMostDefinitelyScaredUser",
+                              "operator": "contains",
+                              "values": "scared",
+                          },
+                      ],
+                  },
+                  {
+                      "percentage": 100,
+                      "segmentType": "alwaysExperiment",
+                      "constraint": "any",
+                      "userConstraints": [
+                          {
+                              "userParam": "isBetaUser",
+                              "operator": "doesNotContain",
+                              "values": "fal",
+                          },
+                          {
+                              "userParam": "isDefinitelyBetaUser",
+                              "operator": "doesNotContain",
+                              "values": "fal",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "everyoneElse",
+                      "userConstraints": [],
+                  },
+              ],
+          },
+      ],
+  },
+}
+
+responseD = {
+  "data": {
+      "features": [
+          {
+              "id": "1",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_TEST",
+              "segments": [],
+          },
+          {
+              "id": "2",
+              "active": false,
+              "description": "foo",
+              "key": "FOO_FALSE_TEST",
+              "segments": [],
+          },
+          {
+              "id": "3",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_50_PERCENT_TEST",
+              "segments": [
+                  {
+                      "constraint": "all",
+                      "segmentType": "everyoneElse",
+                      "percentage": 50,
+                      "userConstraints": [],
+                  },
+              ],
+          },
+          {
+              "id": "4",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_0_PERCENT_TEST",
+              "segments": [
+                  {
+                      "constraint": "all",
+                      "segmentType": "everyoneElse",
+                      "percentage": 0,
+                      "userConstraints": [],
+                  },
+              ],
+          },
+          {
+              "id": "5",
+              "active": true,
+              "description": "foo",
+              "key": "FOO_ID_TEST",
+              "segments": [
+                  {
+                      "constraint": "all",
+                      "percentage": 100,
+                      "segmentType": "alwaysControl",
+                      "userConstraints": [
+                          {
+                              "userParam": "id",
+                              "operator": "equals",
+                              "values": "123",
+                          },
+                      ],
+                  },
+                  {
+                      "constraint": "all",
+                      "segmentType": "everyoneElse",
+                      "percentage": 100,
+                      "userConstraints": [],
+                  },
+              ],
+          },
+      ],
+  },
+}
+
+$client = nil
+$conn = nil
+$stubs = nil
+RSpec.describe Molasses::Client do
+  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
+  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
+  let(:client) { Molasses::Client.new("test_api_key", false) }
+  it "can do basic molasses" do
+    stub_request(:get, 'https://us-central1-molasses-36bff.cloudfunctions.net/get-features').
+      to_return(body:responseA.to_json, headers:  {
+        'Content-Type'=>'application/json',
+        },)
+    expect(client.is_active("FOO_TEST")).to be_truthy
+    expect(client.is_active("FOO_TEST", {"foo"=>"foo"})).to be_truthy
+    expect(client.is_active("NOT_CHECKOUT")).to be_falsy
+    expect(client.is_active("FOO_TEST", {"id"=>"foo", "params"=>{}})).to be_truthy
+    expect(client.is_active("FOO_TEST", {"id"=>"food", "params"=>{
+                      "isScaredUser"=>"true"}})).to be_falsy
+    expect(client.is_active("FOO_TEST", {"id"=>"foodie", "params"=>{
+                      "isBetaUser"=>"true"}})).to be_truthy
+  end
+  it "can do advanced molasses" do
+    stub_request(:get, 'https://us-central1-molasses-36bff.cloudfunctions.net/get-features').
+      to_return(body:responseB.to_json, headers:  {
+        'Content-Type'=>'application/json',
+        },)
+
+    expect(client.is_active("FOO_TEST")).to be_truthy
+    expect(client.is_active("FOO_TEST", {"foo"=>"foo"})).to be_truthy
+    expect(client.is_active("NOT_CHECKOUT")).to be_falsy
+    expect(client.is_active("FOO_TEST", {"id"=>"foo", "params"=>{
+                              "isBetaUser"=>"false", "isScaredUser"=>"false"}})).to be_truthy
+    expect(client.is_active("FOO_TEST", {"id"=>"food", "params"=>{
+                              "isScaredUser"=>"true"}})).to be_falsy
+    expect(client.is_active("FOO_TEST", {"id"=>"foodie", "params"=>{
+                              "isBetaUser"=>"true"}})).to be_truthy
+  end
+  it "can do even more advanced molasses" do
+    stub_request(:get, 'https://us-central1-molasses-36bff.cloudfunctions.net/get-features').
+      to_return(body:responseC.to_json, headers:  {
+        'Content-Type'=>'application/json',
+        },)
+
+    expect(client.is_active("FOO_TEST", {"id"=> "foo", "params" => {
+        "isScaredUser"=> "scared",
+        "isDefinitelyScaredUser"=> "scared",
+        "isMostDefinitelyScaredUser"=> "scared",
+    }})).to be_falsy
+    expect(client.is_active("FOO_TEST", {"id"=>"food", "params"=>{
+                              "isDefinitelyBetaUser"=>"true", "isBetaUser"=>"true"}})).to be_truthy
+    expect(client.is_active("FOO_TEST", {"id"=>"foodie", "params"=>{
+                              "isBetaUser"=>"true"}})).to be_truthy
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: molasses
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Hrisho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Ruby SDK for Molasses. Feature flags as a service
+email: james.hrisho@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/molasses.rb
+- spec/molasses_spec.rb
+homepage: https://molasses.app
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/molassesapp/molasses-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby SDK for Molasses. Feature flags as a service
+test_files: []