tailslide 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6b19ecdf6098906d76624e3b627dcaea697a5f18909d66eb1e20c2b112f8d8c
-  data.tar.gz: 7e65d92225ce3b29ef9f0669174e4f354693fbd6e95135f04895abfa55f2d711
+  metadata.gz: d317d72da4b918e8c57feaf8072884cbc8ecdcb10ab3e49eefc9a392cb7a71ce
+  data.tar.gz: 4edf3d36bf65775916ed49d79ff8c28bd128c91c630bde5b21091353df495d2e
 SHA512:
-  metadata.gz: c788392de48fd095ebbb1a44551a3a99bd6c9df02c229b869d98c480b0ffafc4801fd8c7542771ed644f122400f188764f7a1e094414e9fae49989bd72abfe25
-  data.tar.gz: e3720e9fccd405688385924ceda8e4f997f4e79feab372ce3bd77893791ecc1fb8a5a736f5c81a624737cd3c819d5c35907ef1f5c177e7c3cabc22cfd533d72d
+  metadata.gz: 796bfd026bb228dd49a089a8ed87b8785bc21e7e667e2b6c4f3237a0b3e4de41f3ace73be4efb3b9161baf2c187abb66a74a7f21f8f76c906fef554b1d230659
+  data.tar.gz: 41884a753fed4a3e7c77773ef76059f3cdb1ccd9e63b56cd5efa5ab040590d1726cd1862153ef0eed06eb342d19e5b61868f50a6c2fc17a2c5ef6b6776fc1345

data/.vscode/settings.json

@@ -4,7 +4,8 @@
     "titleBar.activeBackground": "#222222",
     "titleBar.activeForeground": "#e7e7e7",
     "titleBar.inactiveBackground": "#22222299",
-    "titleBar.inactiveForeground": "#e7e7e799"
+    "titleBar.inactiveForeground": "#e7e7e799",
+    "commandCenter.border": "#e7e7e799"
   },
   "editor.acceptSuggestionOnEnter": "on"
 }

data/Gemfile

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in tailslide.gemspec
 gemspec
 
-gem "async", "~> 2,0.3"
-gem "nats-pure", "~> 2,1.0"
-gem "redis", "~>4.7.1"
-gem "redistimeseries", "~>0.1.2"
-gem "rake", "~> 13.0"
+gem 'async', '~> 2,0.3'
+gem 'nats-pure', '~> 2,1.0'
+gem 'rake', '~> 13.0'
+gem 'redis', '~>4.7.1'
+gem 'redistimeseries', '~>0.1.2'
 
-gem "minitest", "~> 5.0"
-
-gem "rubocop", "~> 1.21"
+gem 'minitest', '~> 5.0'
 
+gem 'rubocop', '~> 1.21'

data/README.md

@@ -1,43 +1,215 @@
-# Tailslide
+# Ruby SDK for Tailslide
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/tailslide`. To experiment with that code, run `bin/console` for an interactive prompt.
+---
 
-TODO: Delete this and the text above, and describe your gem
+This package is a server-side SDK for applications written in Ruby for the Tailslide feature flag framework.
+
+Visit the https://github.com/tailslide-io repository or see Tailslide’s [case study](https://tailslide-io.github.io) page for more information.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+---
+
+Install the Tailslide npm package with `gem install tailslide`
+
+## Basic Usage
+
+---
+
+### Instantiating and Initializing FlagManager
+
+The `FlagManager`class is the entry point of this SDK. It is responsible for retrieving all the flag rulesets for a given app with its `app_id` and creating new `Toggler` instances to handle toggling of feature flags within that app. To instantiate a `FlagManager` object, a user must provide a configuration object:
+
+```ruby
+require "async"
+require('tailslide')
+
+config = {
+    nats_server: "nats://localhost:4222",
+    nats_stream: "flags_ruleset",
+    app_id: 1,
+    user_context: "375d39e6-9c3f-4f58-80bd-e5960b710295",
+    sdk_key: "myToken",
+    redis_host: "http://localhost",
+    redis_port: 6379,
+}
+
+Async do |task|
+    manager = FlagManager.new(**config)
+    manager.initialize_flags
+
+end
+```
+
+- `nats_server` is the NATS JetStream server `address:port`
+- `nats_stream` is the NATS JetStream’s stream name that stores all the apps and their flag rulesets
+- `app_id` is the ID number of the app the user wants to retrieve its flag ruleset from
+- `user_context` is the UUID string that identifies the current user
+- `sdk_key` is the SDK key for the Tailslide, it is used as a password for NATS JetStream token authentication
+- `redis_host` is the address to the Redis database
+- `redis_port` is the port number that the Redis database runs on
+
+After instantiating a `FlagManager`, invoke the `initialize` method. This method connects the `FlagManager` instance to both NATS JetStream and Redis Timeseries, and asynchronously retrieves the latest and any new flag ruleset data.
+
+---
+
+### Using Feature Flag with Toggler
+
+Once the `FlagManager` is initialized, it can create a `Toggler`, with the `new_toggler` method, for each feature flag that the developer wants to wrap the new and old features in. A `Toggler`’s `is_flag_active` method checks whether the flag with its `flag_name` is active or not based on the flag ruleset. A `Toggler`’s `is_flag_active` method returns a boolean value, which is intended to be used to control branching logic flow within an application at runtime, to invoke new features.
+
+```ruby
+flag_config = {
+    flag_name: 'App 1 Flag 1',
+}
+
+flag_toggler = manager.new_toggler(flag_config)
+
+if flag_toggler.is_flag_active
+    # call new feature here
+else
+    # call old feature here
+end
+```
+
+---
+
+### Emitting Success or Failture
+
+To use the `Toggler` instances to record successful or failed operations, call its `emit_success` or `emit_failure` methods:
 
 ```ruby
-gem 'tailslide'
+if successCondition
+    flag_toggler.emit_success
+else
+    flag_toggler.emit_failure
+end
 ```
 
-And then execute:
+## Documentation
+
+---
+
+### FlagManager
+
+The `FlagManager` class is the entry point of the SDK. A new `FlagManager` object will need to be created for each app.
+
+#### FlagManager Constructor
+
+**Parameters:**
+
+- An object with the following keys
+  - `server` a string that represents the URL and port of the NATS server.
+  - `app_id` a number representing the application the microservice belongs to
+  - `sdk_key` a string generated via the Tower front-end for NATS JetStream authentication
+  - `user_context` a string representing the user’s UUID
+  - `redis_host` a string that represents the url of the Redis server
+  - `redis_port` a number that represents the port number of the Redis server
+
+---
+
+#### Instance Methods
+
+##### `FlagManager.prototype.set_user_context(new_user_context)`
+
+**Parameters:**
+
+- A UUID string that represents the current active user
+
+**Return Value:**
+
+- `null`
+
+---
+
+##### `FlagManager.prototype.get_user_context()`
+
+**Parameters:**
+
+- `null`
+
+**Return Value:**
+
+- The UUID string that represents the current active user
+
+---
+
+##### `FlagManager.prototype.new_toggler(options)`
+
+Creates a new toggler to check for a feature flag's status from the current app's flag ruleset by the flag's name.
+
+**Parameters:**
+
+- An object with key of `flag_name` and a string value representing the name of the feature flag for the new toggler to check whether the new feature is enabled
+
+**Return Value:**
+
+- A `Toggler` object
+
+---
+
+##### `FlagManager.prototype.disconnect()`
+
+Asynchronously disconnects the `FlagManager` instance from NATS JetStream and Redis database
+
+**Parameters:**
+
+- `null`
+
+**Return Value:**
+
+- `null`
+
+---
+
+### Toggler
+
+The Toggler class provides methods that determine whether or not new feature code is run and handles success/failure emissions. Each toggler handles one feature flag, and is created by `FlagManager.prototype.new_toggler()`.
+
+---
+
+#### Instance Methods
+
+##### `is_flag_active()`
+
+Checks for flag status, whitelisted users, and rollout percentage in that order to determine whether the new feature is enabled.
+
+- If the flag's active status is false, the function returns `false`
+- If current user's UUID is in the whitelist of users, the function returns `true`
+- If current user's UUID hashes to a value within user rollout percentage, the function returns `true`
+- If current user's UUID hashes to a value outside user rollout percentage, the function returns `false`
+
+**Parameters:**
+
+- `null`
+
+**Return Value**
+
+- `true` or `flase` depending on whether the feature flag is active
 
-    $ bundle install
+---
 
-Or install it yourself as:
+##### `emit_success()`
 
-    $ gem install tailslide
+Records a successful operation to the Redis Timeseries database, with key `flagId:success` and value of current timestamp
 
-## Usage
+**Parameters:**
 
-TODO: Write usage instructions here
+- `null`
 
-## Development
+**Return Value**
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+- `null`
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+---
 
-## Contributing
+##### `emit_failure()`
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tailslide. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/tailslide/blob/main/CODE_OF_CONDUCT.md).
+Records a failure operation to the Redis Timeseries database, with key `flagId:success` and value of current timestamp
 
-## License
+**Parameters:**
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+- `null`
 
-## Code of Conduct
+**Return Value**
 
-Everyone interacting in the Tailslide project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/tailslide/blob/main/CODE_OF_CONDUCT.md).
+- `null`

data/lib/tailslide/flag_manager.rb

@@ -2,40 +2,45 @@ require_relative 'nats_client'
 require_relative 'redis_timeseries_client'
 require_relative 'toggler'
 
-class FlagManger
-  attr_reader :nats_client, :redis_ts_client, :user_context
+class FlagManager
 
-  def initialize(nats_server:'', stream:'', app_id:'', sdk_key:'', user_context:'', redis_host:'', redis_port:'')
-    @nats_client = NatsClient.new(server_url: nats_server, stream:stream, subject:app_id, callback:method(:set_flags), token:sdk_key)
+  def initialize(nats_server: '', stream: '', app_id: '', sdk_key: '', user_context: '', redis_host: '', redis_port: '')
+    @nats_client = NatsClient.new(server_url: nats_server, stream: stream, subject: app_id, callback: method(:set_flags),
+                                  token: sdk_key)
     @redis_ts_client = RedisTimeSeriesClient.new(redis_host, redis_port)
     @user_context = user_context
     @flags = []
   end
-  
+
   def initialize_flags
-    nats_client.initialize_flags
-    redis_ts_client.init
+    @nats_client.initialize_flags
+    @redis_ts_client.init
   end
-  
+
   def set_flags(flags)
     @flags = flags
   end
-  
+
   def get_flags
-    return @flags
+    @flags
   end
   
-  def disconnect
-    nats_client.disconnect
-    redis_ts_client.disconnect
+  def set_user_context(new_user_context)
+    @user_context = new_user_context
   end
   
-  def new_toggler(config)
-    p config
+  def get_user_context
+    @user_context
+  end
 
-    return Toggler.new(**config, get_flags:method(:get_flags), user_context:user_context,
-                       emit_redis_signal:redis_ts_client.method(:emit_signal)
-                      )
+  def disconnect
+    @nats_client.disconnect
+    @redis_ts_client.disconnect
   end
-  
-end
+
+  def new_toggler(config)
+    Toggler.new(**config, get_flags: method(:get_flags), user_context: get_user_context,
+                          emit_redis_signal: @redis_ts_client.method(:emit_signal))
+  end
+end
+

data/lib/tailslide/nats_client.rb

@@ -1,53 +1,50 @@
 require 'async'
-require "nats/client"
+require 'nats/client'
 TimeoutError = NATS::IO::Timeout
 require 'json'
 
-
 class NatsClient
   attr_accessor :nats_connection, :jetstream, :subscribed_stream
   attr_reader :connection_string, :stream, :subject, :callback
-  def initialize(server_url:'localhost:4222', stream:'', subject:'', callback:nil, token:'')
+
+  def initialize(server_url: 'localhost:4222', stream: '', subject: '', callback: nil, token: '')
     @stream = stream
-    @subject = subject
+    @subject = format_subject(subject)
     @connection_string = "nats://#{token}#{'@' if token}#{server_url}"
     @callback = callback
   end
-  
+
   def initialize_flags
-    connect()
-    fetch_latest_message()
-    fetch_ongoing_event_messages()
+    connect
+    fetch_latest_message
+    fetch_ongoing_event_messages
   end
-  
+
   private
+
   def connect
     self.nats_connection = NATS.connect(connection_string)
     self.jetstream = nats_connection.jetstream
   end
   
-  def fetch_latest_message
-    begin
-      latest_msg = jetstream.get_last_msg(stream, subject)
-      json_data = JSON.parse latest_msg.data
-      callback.call(json_data)
-    rescue NATS::Timeout => e
-    end
+ def fetch_latest_message
+    latest_msg = jetstream.get_last_msg(stream, subject)
+    json_data = JSON.parse latest_msg.data
+    callback.call(json_data)
+  rescue NATS::Timeout => e
   end
   
   def fetch_ongoing_event_messages
-    Async do |task|
+    Async do |_task|
       self.subscribed_stream = jetstream.pull_subscribe(subject, 'me', config: { deliver_policy: 'new' })
       begin
         messages = subscribed_stream.fetch(1)
         messages.each do |message|
           message.ack
           json_data = JSON.parse message.data
-          p json_data
           callback.call(json_data)
         end
       rescue NATS::IO::Timeout => e
-        p e
       end until nats_connection.closed?
     end
   end
@@ -55,4 +52,9 @@ class NatsClient
   def disconnect
     nats_connection.close
   end
-end
+  
+  def format_subject(subject)
+    "apps.#{subject}.>"
+  end
+end
+

data/lib/tailslide/redis_timeseries_client.rb

@@ -1,21 +1,22 @@
-
 require 'redistimeseries'
 using Redistimeseries::RedisRefinement
 
 class RedisTimeSeriesClient
   attr_reader :host, :port
   attr_accessor :redis_client
+
   def initialize(host, port)
     @host = host || 'localhost'
     @port = port || 6379
   end
 
   def init
-    self.redis_client = Redis.new(host:host, port:port)
+    self.redis_client = Redis.new(host: host, port: port)
   end
-  
+
   def emit_signal(flag_id, app_id, status)
-    redis_client.ts_add(key: "#{flag_id}:#{status}", timestamp:"*", value:1, labels:["status", status, "appId", app_id, "flagId", flag_id])
+    redis_client.ts_add(key: "#{flag_id}:#{status}", timestamp: '*', value: 1,
+                        labels: ['status', status, 'appId', app_id, 'flagId', flag_id])
   end
+end
 
-end

data/lib/tailslide/toggler.rb

@@ -1,13 +1,11 @@
 require 'digest'
 
 class Toggler
-  attr_reader :flag_name, :get_flags, :feature_cb, :default_cb, :error_condition, :emit_redis_signal, :user_context
+  attr_reader :flag_name, :get_flags, :emit_redis_signal, :user_context
   attr_accessor :app_id, :flag_id
-  def initialize(flag_name:'', feature_cb:nil, default_cb:nil, error_condition:nil, get_flags:nil, emit_redis_signal:nil, user_context:'')
+
+  def initialize(flag_name: '', get_flags: nil, emit_redis_signal: nil, user_context: '')
     @flag_name = flag_name
-    @feature_cb = feature_cb
-    @default_cb = default_cb
-    @error_condition = error_condition
     @get_flags = get_flags
     @flag_id = nil
     @app_id = nil
@@ -15,59 +13,62 @@ class Toggler
     @emit_redis_signal = emit_redis_signal
     @user_context = user_context
   end
-  
+
   def is_flag_active
     flag = get_matching_flag
-    flag["is_active"] && (is_user_white_listed(flag) || validate_user_rollout(flag))
+    flag['is_active'] && (is_user_white_listed(flag) || validate_user_rollout(flag))
   end
-  
+
   def emit_success
     return unless flag_id
+
     p 'emiting success'
     emit_redis_signal.call(flag_id, app_id, 'success')
   end
 
   def emit_failure
     return unless flag_id
+
     emit_redis_signal.call(flag_id, app_id, 'failure')
   end
-  
+
   private
+
   def get_matching_flag
-    flag = get_flags.call.find { |flag| flag["title"] == flag_name}
-    raise Exception.new "Cannot find flag with flag name of: #{flag_name}" unless flag
+    flag = get_flags.call.find { |flag| flag['title'] == flag_name }
+    raise Exception, "Cannot find flag with flag name of: #{flag_name}" unless flag
+
     flag
   end
-  
-  def set_flag_id_and_app_id(flag_name)
+
+  def set_flag_id_and_app_id(_flag_name)
     matching_flag = get_matching_flag
-    self.flag_id = matching_flag["id"]
-    self.app_id = matching_flag["app_id"]
+    self.flag_id = matching_flag['id']
+    self.app_id = matching_flag['app_id']
   end
-  
+
   def is_user_white_listed(flag)
-    flag["white_listed_users"].split(',').include?(user_context)
+    flag['white_listed_users'].split(',').include?(user_context)
   end
-  
+
   def validate_user_rollout(flag)
-    rollout = flag["rollout_percentage"] / 100.0
-    if is_circuit_in_recovery(flag)
-      rollout = rollout * (flag["circuit_recovery_percentage"] / 100.0)
-    end
+    rollout = flag['rollout_percentage'] / 100.0
+    rollout *= (flag['circuit_recovery_percentage'] / 100.0) if is_circuit_in_recovery(flag)
     is_user_in_rollout(rollout)
   end
-  
+
   def is_circuit_in_recovery(flag)
-    flag["is_recoverable"] && flag["circuit_status"] == "recovery"
+    flag['is_recoverable'] && flag['circuit_status'] == 'recovery'
   end
-  
+
   def is_user_in_rollout(rollout)
     puts "User context hash #{hash_user_context}"
     puts "Rollout: #{rollout}"
     hash_user_context <= rollout
   end
-  
+
   def hash_user_context
-    (Digest::MD5.hexdigest(user_context).to_i(base=16) % 100) / 100.0
+    (Digest::MD5.hexdigest(user_context).to_i(base = 16) % 100) / 100.0
   end
-end
+end
+

data/lib/tailslide/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tailslide
-  VERSION = "0.1.3"
+  VERSION = '0.1.4'
 end

data/lib/tailslide.rb

@@ -4,7 +4,7 @@ require_relative "tailslide/version"
 require_relative "tailslide/flag_manager"
 
 module Tailslide
-  class FlagManger < FlagManger
+  class FlagManager < FlagManager
   end
   # Your code goes here...
 end

data/test.rb

@@ -1,7 +1,6 @@
 require "async"
 # require "./lib/tailslide/nats_client.rb"
 require_relative "lib/tailslide/flag_manager.rb"
-require_relative 'lib/tailslide/toggler'
 
 # def logMessage(message)
 #   p message
@@ -9,15 +8,15 @@ require_relative 'lib/tailslide/toggler'
 
 # config = {server_url: "localhost:4222", callback: :p, token: 'myToken', stream:"flags", subject:'1'}
 app_id = "1"
-flag_name = 'Flag in app 1 number 1'
+flag_name = 'App 1 Flag 1'
 flag_config = {"flag_name": flag_name}
 
-config = {nats_server:'localhost:4222', stream:'flags', app_id:app_id, sdk_key:'myToken', user_context:'375d39e6-9c3f-4f58-80bd-e5960b710295',
+config = {nats_server:'localhost:4222', stream:'flags_ruleset', app_id:app_id, sdk_key:'myToken', user_context:'375d39e6-9c3f-4f58-80bd-e5960b710295',
    redis_host:'localhost', redis_port:6379}
 
 
 Async do |task|
-  manager = FlagManger.new(**config) 
+  manager = FlagManager.new(**config) 
   manager.initialize_flags
   flag_toggler = manager.new_toggler(flag_config)
   
@@ -29,14 +28,18 @@ Async do |task|
     puts "Flag in #{app_id} with name \"#{flag_name}\" is not active!"
     flag_toggler.emit_failure()
   end
-  sleep 5
-
-  if flag_toggler.is_flag_active
-    puts "Flag in #{app_id} with name \"#{flag_name}\" is active!"
-    flag_toggler.emit_success()
-  else
-    puts "Flag in #{app_id} with name \"#{flag_name}\" is not active!"
-    flag_toggler.emit_failure()
+  
+  count = 0
+  limit = 20
+  while count < limit do
+    if rand < 1
+      flag_toggler.emit_success
+      puts "Emitting success"
+    else
+      flag_toggler.emit_failure
+      puts "Emitting failure"
+    end
+    sleep 1
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tailslide
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Steven Liou
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-24 00:00:00.000000000 Z
+date: 2022-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -93,9 +93,8 @@ files:
 - lib/tailslide/redis_timeseries_client.rb
 - lib/tailslide/toggler.rb
 - lib/tailslide/version.rb
-- redis_test.rb
 - sig/tailslide.rbs
-- tailslide-0.1.0.gem
+- tailslide-0.1.3.gem
 - test.rb
 homepage: https://github.com/tailslide-io/tailslide.rb
 licenses:

data/redis_test.rb

@@ -1,8 +0,0 @@
-require 'redistimeseries'
-using Redistimeseries::RedisRefinement
-
-app_id = 1
-flag_id = 1
-status = 'success'
-redis_client = Redis.new(host:'localhost', port: 6379)
-redis_client.ts_add(key: "#{flag_id}:#{status}", timestamp:"*", value:1, labels:["status", status, "appId", app_id, "flagId", flag_id])