tailslide 0.1.2 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd4e9eea51d59ec4a285b3531dd36e00bb2f437e1df5e50240014c59641c7499
-  data.tar.gz: feaae9d7f5af47900a5031426e9015290a552e0b0eb8060f80b16c2aa148df3d
+  metadata.gz: 8d2f6a5d7784ee42f886c0b8e6565c283c49bdfd3b013bfa272380883f53f223
+  data.tar.gz: ead54dc39be41c0447981804958504b5454ee293e53709876bbfb55a3adbf50a
 SHA512:
-  metadata.gz: 81e5ec75a95f6edce34ad2136376b222e02712bc30b49ed0c0f9423a0a9b9ad78d810269a0002f607d8d9d538779c5e0237e1a264e12dc98fcd59555eb35331b
-  data.tar.gz: c4d4c5276a112b56c2d36596e67a438a47f0f071de792cd46b04021d5e6cfb3fca8d5a712ff26c65eaca9f9565cea7913da8fba5c91db9311b34c6222900ce01
+  metadata.gz: 41643f574dbc72661251707830be8abaf2ffa967d2828becbb85343a28b6346902a493ba52eb53c687c665b7ba8bd12b4bcc7dc2cca59d1a6a369286bebbefd7
+  data.tar.gz: 44647ce3c20988c60ea938e8d23de87e0639006a470c8711156964517b7ba9c1db05ec976855d5c340e679ac60c2a26ca0ec89999e13fc52eeeb2420e38031e5

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,232 @@
-# 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 can be used to evaluate whether a new feature should be used or not.
+
+```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 a `Toggler` instance 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
+  - `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` 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.initialize()`
+
+Asynchronously initialize `flagmanager` connections to NATS JetStream and Redis database
+
+**Parameters:**
+
+- `nil`
+
+**Return Value:**
+
+- `nil`
+
+##### `flagmanaer.set_user_context(new_user_context)`
+
+Set the current user's context for the `flagmanager`
+
+**Parameters:**
+
+- `new_user_context`: A UUID string that represents the current active user
+
+**Return Value:**
+
+- `nil`
+
+---
+
+##### `flagmanaer.get_user_context()`
+
+Returns the current user context
+
+**Parameters:**
+
+- `nil`
+
+**Return Value:**
+
+- The UUID string that represents the current active user
+
+---
+
+##### `flagmanaer.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:**
+
+- `options`: 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
+
+---
+
+##### `flagmanaer.disconnect()`
+
+Asynchronously disconnects the `FlagManager` instance from NATS JetStream and Redis database
+
+**Parameters:**
+
+- `nil`
+
+**Return Value:**
+
+- `nil`
+
+---
+
+### 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 `flagmanaer.new_toggler()`.
+
+---
+
+#### Instance Methods
+
+##### `toggler.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:**
+
+- `nil`
+
+**Return Value**
+
+- `true` or `false` depending on whether the feature flag is active
 
-    $ bundle install
+---
 
-Or install it yourself as:
+##### `toggler.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
+- `nil`
 
-## 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.
+- `nil`
 
-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
+##### `toggler.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).
+- `nil`
 
-## 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).
+- `nil`

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.2"
+  VERSION = '0.1.5'
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tailslide
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.5
 platform: ruby
 authors:
 - Steven Liou
@@ -11,22 +11,64 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-24 00:00:00.000000000 Z
+date: 2022-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: "[]"
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.3
+- !ruby/object:Gem::Dependency
+  name: nats-pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.1
+- !ruby/object:Gem::Dependency
+  name: redistimeseries
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 description: " Write a longer description or delete this line."
 email:
 - stevenliou@gmail.com
@@ -37,8 +79,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".vscode/launch.json"
-- ".vscode/settings.json"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -51,10 +91,7 @@ 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
-- test.rb
 homepage: https://github.com/tailslide-io/tailslide.rb
 licenses:
 - MIT

data/.vscode/launch.json

@@ -1,14 +0,0 @@
-{
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Debug Local File",
-      "type": "Ruby",
-      "request": "launch",
-      "program": "./test.rb"
-    }
-  ]
-}

data/.vscode/settings.json

@@ -1,10 +0,0 @@
-{
-  "workbench.colorCustomizations": {
-    "sash.hoverBorder": "#3b3b3b",
-    "titleBar.activeBackground": "#222222",
-    "titleBar.activeForeground": "#e7e7e7",
-    "titleBar.inactiveBackground": "#22222299",
-    "titleBar.inactiveForeground": "#e7e7e799"
-  },
-  "editor.acceptSuggestionOnEnter": "on"
-}

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])

data/test.rb

@@ -1,129 +0,0 @@
-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
-# end
-
-# 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_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',
-   redis_host:'localhost', redis_port:6379}
-
-
-Async do |task|
-  manager = FlagManger.new(**config) 
-  manager.initialize_flags
-  flag_toggler = manager.new_toggler(flag_config)
-  
-
-  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()
-  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()
-  end
-end
-
-
-# require "nats/client"
-# require "async"
-# TimeoutError = NATS::IO::Timeout
-# require 'json'
-
-# token = "myToken"
-
-# nats_client = NATS.connect("nats://#{token}@127.0.0.1:4222")
-# jet_stream = nats_client.jetstream
-
-# # get last message
-# latest_msg = jet_stream.get_last_msg("flags", "test")
-# json_data = JSON.parse latest_msg.data
-# p json_data
-
-
-# # pull subscribe for new onging messages (workaround until Nats.rb make new update)
-# subscribed_stream = jet_stream.pull_subscribe("test", 'mydurable', config: { deliver_policy: 'new' })
-# Async do |task|
-#   task.async do 
-#       begin
-#       messages = subscribed_stream.fetch(1)
-#       messages.each do |message|
-#         message.ack
-#         json_data = JSON.parse message.data
-#         p json_data
-#       end
-#     rescue NATS::Timeout => e
-#       p e
-#     end until nats_client.closed?
-#   end
-#   p "hello past async"
-# end
-
-
-
-# push subscribe for new ongoing messages
-# setting deliver_policy still results in delivering all messages in "test" subject
-# push_sub = jetStream.subscribe("test", {manual_ack: true, deliver_policy:"new"} ) do |msg|
-#   msg.ack
-#   puts msg.data
-# end
-
-# Get ongoing messages
-# Push subscribe
-# consumer_req = {
-#   stream_name: "test",
-#   config: {
-#     durable_name: "sample",
-#     deliver_policy: "new",
-#     ack_policy: "explicit",
-#     max_deliver: -1,
-#     replay_policy: "instant"
-#   }
-# }
-
-# config = NATS::JetStream::API::ConsumerConfig.new({ deliver_policy: "new" })
-  # Create inbox for push consumer.
-# deliver = natsClient.new_inbox
-# config.deliver_subject = deliver
-
-# push_sub = jetStream.subscribe("test", {manual_ack: true, deliver_policy:"new"} ) do |msg|
-#   puts msg.data
-# end
-
-# cinfo = push_sub.consumer_info["config"]
-# puts cinfo
-# msg = push_sub.next_msg(timeout: 10000000000)
-# msg.ack
-# puts msg.data
-# push_sub.consumer_info["config"]["deliver_policy"] = "new"
-# puts cinfo
-
-# loop do
-#   msgs = push_sub.next_msg()
-#   puts msgs.data
-# rescue TimeoutError => e
-#   puts e
-#   sleep 1
-# end
-
-# js.publish("9", "Hello JetStream! 1")
-# js.publish("9", "Hello JetStream! 2")
-# js.publish("9", "Hello JetStream! 3")
-# js.publish("9", "Hello JetStream! 4")
-# js.publish("9", "Hello JetStream! Latest")