tailslide 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1a5e8473d47cabf7b875eed87f308f7ce87146c9f985be62f03c8de6122fa04
-  data.tar.gz: 7de6db758b0fc8fd7034212ace03061c53a7fc717ab3e68dc87bc46450f69098
+  metadata.gz: d317d72da4b918e8c57feaf8072884cbc8ecdcb10ab3e49eefc9a392cb7a71ce
+  data.tar.gz: 4edf3d36bf65775916ed49d79ff8c28bd128c91c630bde5b21091353df495d2e
 SHA512:
-  metadata.gz: 70b5ddcb2530404fefa63309de3ffbeab55b078cfbd7578890e92e40be4d035510a4c9c3c324a02465894fd8f8e1cab55423ad638acd3911ac73b08973daaaa8
-  data.tar.gz: 17cb8385bdb5c5f320dda627f33ff333ab6a34ae3853d66dfdc8b37bfaf64f124cf2cd2f8bd8572ab043c1fcd1c32dfc8c205e672553c1c69edeb4741bfbe68e
+  metadata.gz: 796bfd026bb228dd49a089a8ed87b8785bc21e7e667e2b6c4f3237a0b3e4de41f3ace73be4efb3b9161baf2c187abb66a74a7f21f8f76c906fef554b1d230659
+  data.tar.gz: 41884a753fed4a3e7c77773ef76059f3cdb1ccd9e63b56cd5efa5ab040590d1726cd1862153ef0eed06eb342d19e5b61868f50a6c2fc17a2c5ef6b6776fc1345

data/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+  // 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

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

data/Gemfile

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in tailslide.gemspec
 gemspec
 
-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 'minitest', '~> 5.0'
 
-gem "rubocop", "~> 1.21"
+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

@@ -0,0 +1,46 @@
+require_relative 'nats_client'
+require_relative 'redis_timeseries_client'
+require_relative 'toggler'
+
+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)
+    @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
+  end
+
+  def set_flags(flags)
+    @flags = flags
+  end
+
+  def get_flags
+    @flags
+  end
+  
+  def set_user_context(new_user_context)
+    @user_context = new_user_context
+  end
+  
+  def get_user_context
+    @user_context
+  end
+
+  def disconnect
+    @nats_client.disconnect
+    @redis_ts_client.disconnect
+  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

@@ -0,0 +1,60 @@
+require 'async'
+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: '')
+    @stream = stream
+    @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
+  end
+
+  private
+
+  def connect
+    self.nats_connection = NATS.connect(connection_string)
+    self.jetstream = nats_connection.jetstream
+  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|
+      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
+          callback.call(json_data)
+        end
+      rescue NATS::IO::Timeout => e
+      end until nats_connection.closed?
+    end
+  end
+  
+  def disconnect
+    nats_connection.close
+  end
+  
+  def format_subject(subject)
+    "apps.#{subject}.>"
+  end
+end
+

data/lib/tailslide/redis_timeseries_client.rb

@@ -0,0 +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)
+  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])
+  end
+end
+

data/lib/tailslide/toggler.rb

@@ -0,0 +1,74 @@
+require 'digest'
+
+class Toggler
+  attr_reader :flag_name, :get_flags, :emit_redis_signal, :user_context
+  attr_accessor :app_id, :flag_id
+
+  def initialize(flag_name: '', get_flags: nil, emit_redis_signal: nil, user_context: '')
+    @flag_name = flag_name
+    @get_flags = get_flags
+    @flag_id = nil
+    @app_id = nil
+    set_flag_id_and_app_id(flag_name)
+    @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))
+  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, "Cannot find flag with flag name of: #{flag_name}" unless flag
+
+    flag
+  end
+
+  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']
+  end
+
+  def is_user_white_listed(flag)
+    flag['white_listed_users'].split(',').include?(user_context)
+  end
+
+  def validate_user_rollout(flag)
+    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'
+  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
+  end
+end
+

data/lib/tailslide/version.rb

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

data/lib/tailslide.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "tailslide/version"
+require_relative "tailslide/flag_manager"
 
 module Tailslide
-  class Error < StandardError; end
+  class FlagManager < FlagManager
+  end
   # Your code goes here...
 end

data/test.rb

@@ -0,0 +1,132 @@
+require "async"
+# require "./lib/tailslide/nats_client.rb"
+require_relative "lib/tailslide/flag_manager.rb"
+
+# def logMessage(message)
+#   p message
+# end
+
+# config = {server_url: "localhost:4222", callback: :p, token: 'myToken', stream:"flags", subject:'1'}
+app_id = "1"
+flag_name = 'App 1 Flag 1'
+flag_config = {"flag_name": flag_name}
+
+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 = FlagManager.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
+  
+  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
+
+
+# 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")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tailslide
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Steven Liou
@@ -11,8 +11,64 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-13 00:00:00.000000000 Z
-dependencies: []
+date: 2022-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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
@@ -23,7 +79,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
+- ".vscode/launch.json"
+- ".vscode/settings.json"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -31,8 +88,14 @@ files:
 - README.md
 - Rakefile
 - lib/tailslide.rb
+- lib/tailslide/flag_manager.rb
+- lib/tailslide/nats_client.rb
+- lib/tailslide/redis_timeseries_client.rb
+- lib/tailslide/toggler.rb
 - lib/tailslide/version.rb
 - sig/tailslide.rbs
+- tailslide-0.1.3.gem
+- test.rb
 homepage: https://github.com/tailslide-io/tailslide.rb
 licenses:
 - MIT
@@ -58,5 +121,6 @@ requirements: []
 rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
-summary: Write a short summary, because RubyGems requires one.
+summary: This is the Ruby SDK for Tailslide, which is a feature flag framework with
+  automatic fail safe and circuit recovery.
 test_files: []

data/.rubocop.yml

@@ -1,13 +0,0 @@
-AllCops:
-  TargetRubyVersion: 2.6
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Layout/LineLength:
-  Max: 120