rollout-redis 0.3.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09b02bf812a6d2bf771a7d9b3d299113d6600c43d88516e40ff43d724c6681b9'
-  data.tar.gz: d18a8829c7ded0e56c2c9f43da26a73e2011d28a7aee15a9011d6246bcc5a166
+  metadata.gz: d3d7a7f17af2164aaeaefcea4ebd6def9fa5a9d29af982e5ed0ad05f2ee4a3a8
+  data.tar.gz: f9b9ff1cd3a1d45fa46695150d705dfff5489937baeaff082718fca7221e90f0
 SHA512:
-  metadata.gz: 8da06a204a6133487f43c52c013485476391b1ff8d2d5680eda8ef9f419aa6b516a63a27fbae3627f0b747b7515fff2347b0594802252ab8b05f78a8b9988154
-  data.tar.gz: 2850a4238642e603504ea4034bd036d09649d319127d99eae4afbe2903f099c7af6d6cc49e50248bfff4b01354982ce93b4b8e58468fdbf7c37dae6801bd0f10
+  metadata.gz: 016c6a7f22c74586628b600bada44d95a3c5934b40c973811e539de286136282d039e1dedc991d6678275b4b25a67a9b3c8139b8403d607ebc78ec27657545d7
+  data.tar.gz: e959cd3d1d9a3a9bbd727b68fef633a30b6e066ecfa0d708bc9dc27db199a6ab9285e2a9709b2696d02af14565055230c02fb85305917f4854454345a7dab005

data/CHANGELOG.md

@@ -4,6 +4,25 @@ All changes to `rollout-redis` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2023-10-28
+
+### Added
+- `#with_old_rollout_gem_compatibility` method for allowing working with Feature Flags that were stored by the old `rollout` gem.
+- `rollout:migrate_from_rollout_format` rake task for performing a migration of the feature flags stored by the old `rollout` gem to the new `rollout-redis` format.
+- Add a new parameter when performing `#activate` method for providing a specific degrade configuration for the feature flag that is being activated.
+- Add a new parameter when performing `rollout:on` rake task for providing a specific degrade configuration for the feature flag that is being activated.
+- You can implement now your own `Rollout::Notifications::Channels::Channel` in case the ones offered by the `gem` are not enough.
+
+## [1.0.0] - 2023-10-25
+
+### Added
+- `#with_notifications` method for allowing to send notifications when some different event occurs.
+
+### Changed
+- When the threshold of errors is reached when using the `with_degrade` feature, instead of deleting the feature flag from the redis, we are marking it now as degraded, moving the activation percentage to 0% and adding some useful information to the feature flag stored data.
+
+## [0.3.1] - 2023-10-24
+- Same as 0.3.0. When testing GitHub actions for moving to first release `1.0.0` it deployed a new version of the gem by error.
 
 ## [0.3.0] - 2023-10-24
 

data/README.md

@@ -14,8 +14,10 @@ Topics covered in this README:
   - [Gradual activation based on percentages](#gradual-activation-based-on-percentages)
   - [Caching Feature Flags](#caching-feature-flags)
   - [Auto-deactivating flags](#auto-deactivating-flags)
+  - [Sending Notifications](#sending-notifications)
 - [Rake tasks](#rake-tasks)
 - [Migrating from rollout gem](#migrating-from-rollout-gem-)
+  - [Compatible payloads and keys](#compatible-payloads-and-keys)
 - [Changelog](#changelog)
 - [Contributing](#contributing)
 
@@ -142,7 +144,7 @@ In the case that you need to clear the cache at any point, you can make use of t
 
 ### Auto-deactivating flags
 
-If you want to allow the gem to deactivate your feature flag automatically when a threshold of erros is reached, you can enable the degrade feature using the `with_degrade` method.
+If you want to allow the gem to deactivate all the feature flags automatically when a threshold of errors is reached, you can enable the degrade feature using the `with_degrade` method.
 
 ```ruby
 @rollout ||= Rollout.new(redis)
@@ -150,6 +152,18 @@ If you want to allow the gem to deactivate your feature flag automatically when
               .with_degrade(min: 100, threshold: 0.1)
 ```
 
+However, if you just want to activate the degradation of an specific feature flag, you need to provide the following information when activating the feature flag (note that now the percentage is a mandatory parameter if you want to pass the degrade options):
+
+```ruby
+@rollout.activate('FEATURE_FLAG_NAME', 100, degrade: { min: 500, threshold: 0.2 })
+```
+
+The same configuration 👆 is available when using the rake task for activating the feature flag. Check [Rake tasks](#rake-tasks) section.
+
+```shell
+bundle exec rake rollout:on[FEATURE_FLAG_NAME,100,500,0.2]
+```
+
 So now, instead of using the `active?` method, you need to wrap your new code under the `with_feature` method.
 
 ```ruby
@@ -158,7 +172,99 @@ So now, instead of using the `active?` method, you need to wrap your new code un
 end
 ```
 
-When any unexpected error appears during the wrapped code execution, the Rollout gem will take it into account for automatically deactivating the feature flag if the threshold of errors is reached. All the managed or captured errors inside the wrapped code will not be taken into consideration.
+When any unexpected error appears during the wrapped code execution, the Rollout gem will take it into account for automatically degrading the feature flag if the threshold of errors is reached. The feature flag will not be removed from the redis, but it will change its percentage to 0 and it will be marked as degraded.
+
+_NOTE_: All the managed or captured errors inside the wrapped code will not be taken into consideration for degrading the feature flag.
+
+### Sending notifications
+
+`rollout-redis` gem can send different notifications to your development team. For enabling this feature, you just need to use the `with_notifications` instance method providing the channels where you want to publish each of the different events that can occur:
+
+- **status_change**: This notification is triggered when a feature flag is activated or deactivated using the `rollout-redis` gem.
+- **degrade**: This notification is triggered when a feature flag is automatically degraded because the threshold of errors is reached
+  - The instance must be configured for automatically degrading using the `with_degrade` instance method.
+
+You must provide at least one [channel](#defining-the-channels) as a parameter if you want to enable the notifications for that specific event. If no channels provided, the notifications will not be sent. 
+
+```ruby
+@rollout ||= Rollout.new(redis)
+              .with_cache
+              .with_degrade(min: 100, threshold: 0.1)
+              .with_notifications(
+                status_change: [slack_channel],
+                degrade: [slack_channel, email_channel]
+              )
+```
+
+#### Defining the channels
+
+When enabling a notification, you can provide the different channels where the notification should be published. `rollout-redis` gem offers different channels that can be configured.
+
+##### Slack Channel
+
+Allows you to send notifications using a slack webhook.
+
+The first thing to do is to setup an incoming webhook service integration. You can do this from your services page.
+
+After that, you can provide the obtained webhook url when instantiating the Slack channel.
+
+```ruby
+require 'rollout'
+
+slack_channel = Rollout::Notifications::Channels::Slack.new(
+  webhook_url: ENV.fetch('SLACK_COMPANY_WEBHOOK_URL'),
+  channel: '#feature-flags-notifications',
+  username: 'rollout-redis'
+)
+```
+
+##### Email Channel
+
+Allows you to send notifications via email.
+
+```ruby
+require 'rollout'
+
+email_channel = Rollout::Notifications::Channels::Email.new(
+  smtp_host: ENV.fetch('SMTP_HOST'),
+  smtp_port: ENV.fetch('SMTP_PORT'),
+  from: 'no-reply@rollout-redis.com',
+  to: 'developers@yourcompany.com'
+)
+```
+
+##### Custom channel
+
+If you want to send the notifications using a different channel not offered by this gem, you can implement your own class with a `publish` method.
+
+```ruby
+require 'rollout'
+
+module YourApp
+  class YourCustomChannel
+    def initialize()
+      # provide here whatever you need for configuring your channel
+    end
+
+    def publish(text)
+      # Implement the way you want to publish the notification
+    end
+  end
+end
+```
+
+After implementing it, you can pass it to the list of configured channels
+
+```ruby
+your_channel = YourApp::YourCustomChannel.new(url: 'wadus', param2: 'foo')
+@rollout ||= Rollout.new(redis)
+              .with_cache
+              .with_degrade(min: 100, threshold: 0.1)
+              .with_notifications(
+                status_change: [your_channel],
+                degrade: [your_channel]
+              )
+```
 
 ## Rake tasks
 
@@ -200,10 +306,20 @@ For listing all the stored feature flags, do:
 bundle exec rake rollout:list
 ```
 
+For migrating feature flags stored using the old `rollout` gem format (check [migration guide](https://github.com/jcagarcia/rollout-redis/blob/main/MIGRATING_FROM_ROLLOUT_GEM.md)), do:
+
+```shell
+bundle exec rake rollout:migrate_from_rollout_format
+```
+
 ## Migrating from rollout gem 🚨
 
 If you are currently using the unmaintained [rollout](https://github.com/fetlife/rollout) gem, you should consider checking this [migration guide](https://github.com/jcagarcia/rollout-redis/blob/main/MIGRATING_FROM_ROLLOUT_GEM.md) for start using the new `rollout-redis` gem.
 
+### Compatible payloads and keys
+
+You can use the `.with_old_rollout_gem_compatibility` instance method for making the `rollout-redis` gem work as the the discontinued [rollout](https://github.com/fetlife/rollout) gem in terms of redis storage and format storage. Check the [migration guide](https://github.com/jcagarcia/rollout-redis/blob/main/MIGRATING_FROM_ROLLOUT_GEM.md) for more information.
+
 ## Changelog
 
 If you're interested in seeing the changes and bug fixes between each version of `rollout-redis`, read the [Changelog](https://github.com/jcagarcia/rollout-redis/blob/main/CHANGELOG.md).
@@ -226,7 +342,9 @@ We welcome and appreciate contributions from the open-source community. Before y
 
 ### Development
 
-This project is dockerized. Once you clone the repository, you can use the `Make` commands to build the project.
+This project is dockerized, so be sure you have docker installed in your machine. 
+
+Once you clone the repository, you can use the `Make` commands to build the project.
 
 ```shell
 make build

data/lib/rollout/feature.rb

@@ -4,7 +4,7 @@ require 'zlib'
 
 class Rollout
     class Feature
-      attr_accessor :percentage
+      attr_accessor :percentage, :degrade
       attr_reader :name, :data
 
       RAND_BASE = (2**32 - 1) / 100.0
@@ -13,6 +13,7 @@ class Rollout
         @name = name
         @data = data
         @percentage = @data[:percentage]
+        @degrade = @data[:degrade]
       end
   
       def active?(determinator=nil)
@@ -48,7 +49,7 @@ class Rollout
       end
 
       def to_h
-        {
+        h = {
           name: @name,
           percentage: @percentage,
           data: {
@@ -56,6 +57,12 @@ class Rollout
             errors: errors
           }
         }
+
+        h.merge!({
+          degrade: @degrade
+        }) if @degrade
+
+        h
       end
   
       private

data/lib/rollout/notifications/channels/email.rb

@@ -0,0 +1,27 @@
+require 'mail'
+
+class Rollout
+  module Notifications
+    module Channels
+      class Email
+        def initialize(smtp_host:, smtp_port:, from:'no-reply@rollout-redis.com', to:)
+          @smtp_host = smtp_host
+          @smtp_port = smtp_port
+          @from = from
+          @to = to
+        end
+
+        def publish(subject, body)
+          mail = Mail.new do
+            subject  subject
+            body     body
+          end
+          mail.smtp_envelope_from = @from
+          mail.smtp_envelope_to = @to
+          mail.delivery_method :smtp, address: @smtp_host, port: @smtp_port
+          mail.deliver
+        end
+      end
+    end
+  end
+end 

data/lib/rollout/notifications/channels/slack.rb

@@ -0,0 +1,41 @@
+require 'slack-notifier'
+
+class Rollout
+  module Notifications
+    module Channels
+      class Slack
+        def initialize(webhook_url:, channel:, username:'rollout-redis')
+          @webhook_url = webhook_url
+          @channel = channel
+          @username = username
+        end
+
+        def publish(text)
+          begin
+            blocks = [
+              {
+                "type": "section",
+                "text": {
+                  "type": "mrkdwn",
+                  "text": text
+                }
+              }
+            ]
+            slack_notifier.post(blocks: blocks)
+          rescue => e
+            puts "[ERROR] Error sending notification to slack webhook. Error => #{e}"
+          end
+        end
+
+        private
+
+        def slack_notifier
+          @notifier ||= ::Slack::Notifier.new @webhook_url do
+            defaults channel: @channel,
+                     username: @username
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rollout/notifications/notifiers/base.rb

@@ -0,0 +1,15 @@
+class Rollout
+  module Notifications
+    module Notifiers
+      class Base
+        def initialize(channels)
+          if channels.respond_to?(:first)
+            @channels = channels
+          else
+            @channels = [channels]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rollout/notifications/notifiers/degrade.rb

@@ -0,0 +1,36 @@
+require_relative 'base'
+
+class Rollout
+  module Notifications
+    module Notifiers
+      class Degrade < Base
+        def initialize(channels)
+          super(channels)
+        end
+
+        def notify(feature_name, requests, errors)
+          @channels.each do |c|
+            if c.class == Rollout::Notifications::Channels::Email
+              publish_to_email_channel(c, feature_name, requests, errors)
+            else
+              publish_to_channel(c, feature_name, requests, errors)
+            end
+          end
+        end
+
+        private
+
+        def publish_to_channel(c, feature_name, requests, errors)
+          text = "Feature flag '#{feature_name}' has been degraded after #{requests} requests and #{errors} errors"
+          c.publish(text)
+        end
+
+        def publish_to_email_channel(c, feature_name, requests, errors)
+          subject = 'Feature flag has been automatically deactivated!'
+          content = "Feature flag '#{feature_name}' has been degraded after #{requests} requests and #{errors} errors"
+          c.publish(subject, content)
+        end
+      end
+    end
+  end
+end

data/lib/rollout/notifications/notifiers/status_change.rb

@@ -0,0 +1,45 @@
+require_relative 'base'
+
+class Rollout
+  module Notifications
+    module Notifiers
+      class StatusChange < Base
+        def initialize(channels)
+          super(channels)
+        end
+
+        def notify(feature_name, new_status, new_percentage=nil)
+          @channels.each do |c|
+            if c.class == Rollout::Notifications::Channels::Email
+              publish_to_email_channel(c, feature_name, new_status, new_percentage)
+            else
+              publish_to_channel(c, feature_name, new_status, new_percentage)
+            end
+          end
+        end
+
+        private
+
+        def publish_to_channel(c, feature_name, new_status, new_percentage)
+          if new_status == :activated
+            text = "Feature flag '#{feature_name}' has been activated with percentage #{new_percentage}!"
+          elsif new_status == :deactivated
+            text = "Feature flag '#{feature_name}' has been deactivated and deleted!"
+          end
+          c.publish(text)
+        end
+
+        def publish_to_email_channel(c, feature_name, new_status, new_percentage)
+          if new_status == :activated
+            subject = 'Feature flag has been activated!'
+            content = "Feature flag '#{feature_name}' has been activated with percentage #{new_percentage}!"
+          elsif new_status == :deactivated
+            subject = 'Feature flag has been deactivated!'
+            content = "Feature flag '#{feature_name}' has been deactivated and deleted!"
+          end
+          c.publish(subject, content)
+        end
+      end
+    end
+  end
+end

data/lib/rollout/tasks/rollout.rake

@@ -1,13 +1,20 @@
 
 namespace :rollout do
   desc "Activate a feature"
-  task :on, [:feature, :percentage] => :environment do |task, args|
+  task :on, [:feature, :percentage, :degrade_min, :degrade_threshold] => :environment do |task, args|
     if args.feature
-      puts "Activating feature #{args.feature}..."
       if args.percentage
-        activated = rollout.activate(args.feature, args.percentage.to_i)
+        percentage = args.percentage.to_i
       else
-        activated = rollout.activate(args.feature)
+        percentage = 100
+      end
+
+      if args.degrade_min && args.degrade_threshold
+        puts "Activating feature #{args.feature} at #{percentage}% (degrade config set to a min of #{args.degrade_min} requests and a threshold of error of #{args.degrade_threshold.to_f*100}%)..."
+        activated = rollout.activate(args.feature, percentage, degrade: { min: args.degrade_min.to_i, threshold: args.degrade_threshold.to_f})
+      else
+        puts "Activating feature #{args.feature} at #{percentage}%..."
+        activated = rollout.activate(args.feature, percentage)
       end
 
       if activated
@@ -43,6 +50,13 @@ namespace :rollout do
     end
   end
 
+  desc "Migrate stored feature flags to the new format without removing the old information"
+  task migrate_from_rollout_format: :environment do
+    puts "Starting the migration..."
+    rollout.migrate_from_rollout_format
+    puts "Migration has finished!"
+  end
+
   private
 
   def rollout

data/lib/rollout/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Rollout
-  VERSION = '0.3.1'
+  VERSION = '1.1.0'
 end

data/lib/rollout.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
-require 'rollout/feature'
-require 'rollout/version'
 require 'redis'
 require 'json'
 
+require 'rollout/feature'
+require 'rollout/notifications/channels/email'
+require 'rollout/notifications/channels/slack'
+require 'rollout/notifications/notifiers/degrade'
+require 'rollout/notifications/notifiers/status_change'
+require 'rollout/version'
+
+
 class Rollout
 
   class Error < StandardError; end
@@ -15,6 +21,8 @@ class Rollout
     @storage = storage
     @cache_enabled = false
     @degrade_enabled = false
+    @old_gem_compatibility_enabled = false
+    @auto_migrate_from_old_format = false
   end
 
   def with_cache(expires_in: 300)
@@ -33,14 +41,56 @@ class Rollout
     self
   end
 
-  def activate(feature_name, percentage=100)
+  def with_notifications(status_change:[], degrade:[])
+    status_change_channels = status_change
+    degrade_channels = degrade
+
+    if !status_change_channels.empty?
+      status_change_channels.each do |c|
+        raise Rollout::Error.new("Channel #{c.class.name} does not implement `publish` method") unless c.respond_to?(:publish)
+      end
+      @status_change_notifier = Notifications::Notifiers::StatusChange.new(status_change_channels)
+    end
+
+    if !degrade_channels.empty?
+      degrade_channels.each do |c|
+        raise Rollout::Error.new("Channel #{c.class.name} does not implement `publish` method") unless c.respond_to?(:publish)
+      end
+      @degrade_notifier = Notifications::Notifiers::Degrade.new(degrade_channels)
+    end
+
+    self
+  end
+
+  def with_old_rollout_gem_compatibility(auto_migration: false)
+    @old_gem_compatibility_enabled = true
+    @auto_migrate_from_old_format = auto_migration
+
+    self
+  end
+
+  def activate(feature_name, percentage=100, degrade: nil)
     data = { percentage: percentage }
+    data.merge!({
+      degrade: {
+        min: degrade[:min] || 0,
+        threshold: degrade[:threshold] || 0
+      }
+    }) if degrade
+
     feature = Feature.new(feature_name, data)
-    @cache[feature_name] = {
-      feature: feature,
-      timestamp: Time.now.to_i
-    } if @cache_enabled
-    save(feature) == "OK"
+    result = save(feature) == "OK"
+
+    if result
+      @cache[feature_name] = {
+        feature: feature,
+        timestamp: Time.now.to_i
+      } if @cache_enabled
+
+      @status_change_notifier&.notify(feature_name, :activated, percentage)
+    end
+
+    result
   end
 
   def activate_percentage(feature_name, percentage)
@@ -48,16 +98,27 @@ class Rollout
   end
 
   def deactivate(feature_name)
-    del(feature_name)
+    result = del(feature_name)
+
+    @status_change_notifier&.notify(feature_name, :deactivated)
+
+    result
   end
 
   def active?(feature_name, determinator = nil)
-    feature = get(feature_name, determinator)
+    feature = get(feature_name)
+    if feature.nil? && @old_gem_compatibility_enabled
+      feature = get_with_old_format(feature_name)
+      if feature && @auto_migrate_from_old_format
+        activate(feature_name, feature.percentage)
+      end
+    end
+
     return false unless feature
 
     active = feature.active?(determinator)
 
-    if active && @degrade_enabled
+    if active && degrade_enabled?(feature)
       feature.add_request
       save(feature)
     end
@@ -67,13 +128,15 @@ class Rollout
 
   def with_feature_flag(feature_name, determinator = nil, &block)
     yield if active?(feature_name, determinator)
+  rescue Rollout::Error => e
+    raise
   rescue => e
-    feature = get(feature_name, determinator)
-    if @degrade_enabled && feature
+    feature = get(feature_name)
+    if feature && degrade_enabled?(feature)
       feature.add_error
       save(feature)
 
-      deactivate(feature_name) if degraded?(feature)
+      degrade(feature_name) if degraded?(feature)
     end
     raise e
   end
@@ -115,14 +178,18 @@ class Rollout
 
         @storage.set(new_key, new_data)
 
-        puts "Migrated key: #{old_key} to #{new_key} with data #{new_data}"
+        puts "Migrated redis key from #{old_key} to #{new_key}. Migrating data from '#{old_data}' to '#{new_data}'."
+
+        if percentage > 0
+          @status_change_notifier&.notify(new_key.gsub('feature-rollout-redis:', ''), :activated, percentage)
+        end
       end
     end
   end
 
   private
 
-  def get(feature_name, determinator = nil)
+  def get(feature_name)
     feature = from_redis(feature_name)
     return unless feature
 
@@ -139,6 +206,15 @@ class Rollout
     cached_feature
   end
 
+  def get_with_old_format(feature_name)
+    feature = from_redis_with_old_format(feature_name)
+    return unless feature
+
+    feature
+  rescue ::Redis::BaseError => e
+    raise Rollout::Error.new(e)
+  end
+
   def save(feature)
     @storage.set(key(feature.name), feature.data.to_json)
   end
@@ -147,6 +223,22 @@ class Rollout
     @storage.del(key(feature_name)) == 1
   end
 
+  def degrade(feature_name)
+    feature = get(feature_name)
+    data_with_degrade = feature.data.merge({
+      percentage: 0,
+      degraded: true,
+      degraded_at: Time.now
+    })
+    result = @storage.set(key(feature.name), data_with_degrade.to_json) == "OK"
+
+    if result
+      @degrade_notifier.notify(feature_name, feature.requests, feature.errors)
+    end
+
+    result
+  end
+
   def from_cache(feature_name)
     return nil unless @cache_enabled
 
@@ -166,22 +258,58 @@ class Rollout
     Feature.new(feature_name, JSON.parse(data, symbolize_names: true))
   end
 
+  def from_redis_with_old_format(feature_name)
+    old_data = @storage.get(old_key(feature_name))
+    return unless old_data
+
+    percentage = old_data.split('|')[0].to_i
+
+    new_data = {
+      percentage: percentage,
+      requests: 0,
+      errors: 0
+    }
+
+    Feature.new(feature_name, new_data)
+  end
+
   def expired?(timestamp)
     Time.now.to_i - timestamp > @cache_time
   end
 
   def degraded?(feature)
-    return false if !@degrade_enabled
-    return false if feature.requests < @degrade_min
+    return false if !degrade_enabled?(feature)
+
+    if feature.degrade
+      degrade_min = feature.degrade[:min]
+      degrade_threshold = feature.degrade[:threshold]
+    else
+      degrade_min = @degrade_min
+      degrade_threshold = @degrade_threshold
+    end
 
-    feature.errors > @degrade_threshold * feature.requests
+    return false if feature.requests < degrade_min
+
+    feature.errors > degrade_threshold * feature.requests
+  end
+
+  def degrade_enabled?(feature)
+    @degrade_enabled || !feature.degrade.nil?
   end
 
   def key(name)
     "#{key_prefix}:#{name}"
   end
 
+  def old_key(name)
+    "#{old_key_prefix}:#{name}"
+  end
+
   def key_prefix
     "feature-rollout-redis"
   end
+
+  def old_key_prefix
+    "feature"
+  end
 end

data/rollout-redis.gemspec

@@ -23,6 +23,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3'
 
   spec.add_runtime_dependency 'redis', '>= 4.0', '<= 5'
+  spec.add_runtime_dependency 'slack-notifier', '~> 2.4'
+  spec.add_runtime_dependency 'mail', '~> 2.8'
 
   spec.add_development_dependency 'bundler', '>= 2.4'
   spec.add_development_dependency 'rspec', '~> 3.12'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollout-redis
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Juan Carlos García
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-24 00:00:00.000000000 Z
+date: 2023-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -30,6 +30,34 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: slack-notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -98,6 +126,11 @@ files:
 - Rakefile
 - lib/rollout.rb
 - lib/rollout/feature.rb
+- lib/rollout/notifications/channels/email.rb
+- lib/rollout/notifications/channels/slack.rb
+- lib/rollout/notifications/notifiers/base.rb
+- lib/rollout/notifications/notifiers/degrade.rb
+- lib/rollout/notifications/notifiers/status_change.rb
 - lib/rollout/tasks/rollout.rake
 - lib/rollout/version.rb
 - rollout-redis.gemspec