rollout 2.4.6 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3e6e9521ed03059b5b673616e985f89231d77d1ca42d8fa7ff00797ef906768
-  data.tar.gz: ac66f6f5f0da7e03bbf506d09f62d34e6afd7f1ea09b248b5193d74f3b6a720e
+  metadata.gz: 58914b07d5596f1db7ce88d65de6e5286519e4b527377b40b7c56ad3ea799323
+  data.tar.gz: 4200f92c9784c3d3f6d275a4308714c7b55d35154c97ef01a89a04166e69c041
 SHA512:
-  metadata.gz: ccebf1c2024c332cd921a49b400a7ee8e9a5c0ce95cdf59f5e89fb302bef08684cc04ffae30c952e14ffd5acc97d583871ee590aebe6aa2c519cc416afc17b9f
-  data.tar.gz: fe0a400d1f694a6aefb5b1e7d89afb64a8cb28c07a1f510d01655d724bfb97d5b38e7c60e40669aec5fded5581e760549b53564078018cad92c968b6900753ee
+  metadata.gz: 4e3fcddc89ff58fe0d652eed810767eba1a03a4a23312f9bceb174e63348b07fd47592a1504316c3e42169610f24fc78580b846b5649200159dcef6c6ffdbdb7
+  data.tar.gz: 02cc8771d302d5e0b33fb370d6a9ed063f5b7d05406f4ec57689f2196921e5ec4e1382b1a1fd175d7804e316f98538d0e2809e6ad7fe25847e06466dd12cafbc

data/.circleci/config.yml

@@ -3,58 +3,64 @@ version: 2.1
 workflows:
   main:
     jobs:
+      - ruby33
+      - ruby31
+      - ruby32
+      - ruby30
       - ruby27
       - ruby26
       - ruby25
       - ruby24
-      - ruby23
 
 executors:
+  ruby33:
+    docker:
+      - image: cimg/ruby:3.3
+      - image: cimg/redis:7.2
+  ruby32:
+    docker:
+      - image: cimg/ruby:3.2
+      - image: cimg/redis:7.2
+  ruby31:
+    docker:
+      - image: cimg/ruby:3.1
+      - image: cimg/redis:7.2
+  ruby30:
+    docker:
+      - image: cimg/ruby:3.0
+      - image: cimg/redis:7.2
   ruby27:
     docker:
-      - image: circleci/ruby:2.7
-      - image: circleci/redis:alpine
+      - image: cimg/ruby:2.7
+      - image: cimg/redis:7.2
   ruby26:
     docker:
-      - image: circleci/ruby:2.6
-      - image: circleci/redis:alpine
+      - image: cimg/ruby:2.7
+      - image: cimg/redis:7.2
   ruby25:
     docker:
-      - image: circleci/ruby:2.5
-      - image: circleci/redis:alpine
+      - image: cimg/ruby:2.7
+      - image: cimg/redis:7.2
   ruby24:
     docker:
-      - image: circleci/ruby:2.4
-      - image: circleci/redis:alpine
-  ruby23:
-    docker:
-      - image: circleci/ruby:2.3
-      - image: circleci/redis:alpine
+      - image: cimg/ruby:2.4
+      - image: cimg/redis:7.2
 
 commands:
   test:
     steps:
-      - restore_cache:
-          keys:
-            - bundler-{{ checksum "Gemfile.lock" }}
-
       - run:
           name: Bundle Install
           command: bundle check --path vendor/bundle || bundle install
 
-      - save_cache:
-          key: bundler-{{ checksum "Gemfile.lock" }}
-          paths:
-            - vendor/bundle
-
       - run:
           name: Run rspec
           command: |
             bundle exec rspec --format documentation --format RspecJunitFormatter --out test_results/rspec.xml
 
 jobs:
-  ruby27:
-    executor: ruby27
+  ruby33:
+    executor: ruby33
     steps:
       - checkout
       - test
@@ -70,26 +76,44 @@ jobs:
       - store_test_results:
           path: test_results
 
-  ruby26:
-    executor: ruby26
+  ruby32:
+    executor: ruby30
     steps:
       - checkout
       - test
 
-  ruby25:
-    executor: ruby25
+  ruby31:
+    executor: ruby30
     steps:
       - checkout
       - test
 
-  ruby24:
-    executor: ruby24
+  ruby30:
+    executor: ruby30
     steps:
       - checkout
       - test
 
-  ruby23:
-    executor: ruby23
+  ruby27:
+    executor: ruby27
+    steps:
+      - checkout
+      - test
+
+  ruby26:
+    executor: ruby27
+    steps:
+      - checkout
+      - test
+
+  ruby25:
+    executor: ruby27
+    steps:
+      - checkout
+      - test
+
+  ruby24:
+    executor: ruby24
     steps:
       - checkout
       - test

data/README.md

@@ -28,7 +28,7 @@ or even simpler
 
 ```ruby
 require 'redis'
-$rollout = Rollout.new(Redis.current) # Will use REDIS_URL env var or default redis url
+$rollout = Rollout.new($redis) # Will use REDIS_URL env var or default redis url
 ```
 
 
@@ -161,6 +161,15 @@ deactivate them automatically when a threshold is reached to prevent service
 failures from cascading. See https://github.com/jamesgolick/degrade for the
 failure detection code.
 
+## Check Rollout Feature
+
+You can inspect the state of your feature using:
+
+```ruby
+>> $rollout.get(:chat)
+=> #<Rollout::Feature:0x00007f99fa4ec528 @data={}, @groups=[:caretakers], @name=:chat, @options={}, @percentage=0.05, @users=["1"]>
+```
+
 ## Namespacing
 
 Rollout separates its keys from other keys in the data store using the
@@ -180,6 +189,7 @@ This example would use the "development:feature:chat:groups" key.
 
 ## Frontend / UI
 
+* [rollout-ui](https://github.com/fetlife/rollout-ui)
 * [Rollout-Dashboard](https://github.com/fiverr/rollout_dashboard/)
 
 ## Implementations in other languages
@@ -188,6 +198,7 @@ This example would use the "development:feature:chat:groups" key.
 *   PHP: https://github.com/opensoft/rollout
 *   Clojure: https://github.com/yeller/shoutout
 *   Perl: https://metacpan.org/pod/Toggle
+*   Golang: https://github.com/SalesLoft/gorollout
 
 
 ## Contributors

data/lib/rollout/feature.rb

@@ -5,12 +5,13 @@ class Rollout
     attr_accessor :groups, :users, :percentage, :data
     attr_reader :name, :options
 
-    def initialize(name, string = nil, opts = {})
-      @options = opts
-      @name    = name
+    def initialize(name, rollout:, state: nil, options: {})
+      @name = name
+      @rollout = rollout
+      @options = options
 
-      if string
-        raw_percentage, raw_users, raw_groups, raw_data = string.split('|', 4)
+      if state
+        raw_percentage, raw_users, raw_groups, raw_data = state.split('|', 4)
         @percentage = raw_percentage.to_f
         @users = users_from_string(raw_users)
         @groups = groups_from_string(raw_groups)
@@ -48,12 +49,12 @@ class Rollout
       @data = {}
     end
 
-    def active?(rollout, user)
+    def active?(user)
       if user
         id = user_id(user)
         user_in_percentage?(id) ||
           user_in_active_users?(id) ||
-          user_in_active_group?(user, rollout)
+          user_in_active_group?(user)
       else
         @percentage == 100
       end
@@ -67,10 +68,19 @@ class Rollout
       {
         percentage: @percentage,
         groups: @groups,
-        users: @users
+        users: @users,
+        data: @data,
       }
     end
 
+    def deep_clone
+      c = self.clone
+      c.instance_variable_set('@rollout', nil)
+      c = Marshal.load(Marshal.dump(c))
+      c.instance_variable_set('@rollot', @rollout)
+      c
+    end
+
     private
 
     def user_id(user)
@@ -97,9 +107,9 @@ class Rollout
       end
     end
 
-    def user_in_active_group?(user, rollout)
+    def user_in_active_group?(user)
       @groups.any? do |g|
-        rollout.active_in_group?(g, user)
+        @rollout.active_in_group?(g, user)
       end
     end
 

data/lib/rollout/logging.rb

@@ -0,0 +1,199 @@
+class Rollout
+  module Logging
+    def self.extended(rollout)
+      options = rollout.options[:logging]
+      options = options.is_a?(Hash) ? options.dup : {}
+      options[:storage] ||= rollout.storage
+
+      logger = Logger.new(**options)
+
+      rollout.add_observer(logger, :log)
+      rollout.define_singleton_method(:logging) do
+        logger
+      end
+    end
+
+    class Event
+      attr_reader :feature, :name, :data, :context, :created_at
+
+      def self.from_raw(value, score)
+        hash = JSON.parse(value, symbolize_names: true)
+
+        new(**hash.merge(created_at: Time.at(-score.to_f / 1_000_000)))
+      end
+
+      def initialize(feature: nil, name:, data:, context: {}, created_at:)
+        @feature = feature
+        @name = name
+        @data = data
+        @context = context
+        @created_at = created_at
+      end
+
+      def timestamp
+        (@created_at.to_f * 1_000_000).to_i
+      end
+
+      def serialize
+        JSON.dump(
+          feature: @feature,
+          name: @name,
+          data: @data,
+          context: @context,
+          created_at: @created_at,
+        )
+      end
+
+      def ==(other)
+        feature == other.feature \
+          && name == other.name \
+          && data == other.data \
+          && created_at == other.created_at
+      end
+    end
+
+    class Logger
+      def initialize(storage: nil, history_length: 50, global: false)
+        @history_length = history_length
+        @storage = storage
+        @global = global
+      end
+
+      def updated_at(feature_name)
+        storage_key = events_storage_key(feature_name)
+        _, score = @storage.zrange(storage_key, 0, 0, with_scores: true).first
+        Time.at(-score.to_f / 1_000_000) if score
+      end
+
+      def last_event(feature_name)
+        storage_key = events_storage_key(feature_name)
+        value = @storage.zrange(storage_key, 0, 0, with_scores: true).first
+        Event.from_raw(*value) if value
+      end
+
+      def events(feature_name)
+        storage_key = events_storage_key(feature_name)
+        @storage
+          .zrange(storage_key, 0, -1, with_scores: true)
+          .map { |v| Event.from_raw(*v) }
+          .reverse
+      end
+
+      def global_events
+        @storage
+          .zrange(global_events_storage_key, 0, -1, with_scores: true)
+          .map { |v| Event.from_raw(*v) }
+          .reverse
+      end
+
+      def delete(feature_name)
+        storage_key = events_storage_key(feature_name)
+        @storage.del(storage_key)
+      end
+
+      def update(before, after)
+        before_hash = before.to_hash
+        before_hash.delete(:data).each do |k, v|
+          before_hash["data.#{k}"] = v
+        end
+        after_hash = after.to_hash
+        after_hash.delete(:data).each do |k, v|
+          after_hash["data.#{k}"] = v
+        end
+
+        keys = before_hash.keys | after_hash.keys
+        change = { before: {}, after: {} }
+        changed_count = 0
+
+        keys.each do |key|
+          next if before_hash[key] == after_hash[key]
+
+          change[:before][key] = before_hash[key]
+          change[:after][key] = after_hash[key]
+
+          changed_count += 1
+        end
+
+        return if changed_count == 0
+
+        event = Event.new(
+          feature: after.name,
+          name: :update,
+          data: change,
+          context: current_context,
+          created_at: Time.now,
+        )
+
+        storage_key = events_storage_key(after.name)
+
+        @storage.zadd(storage_key, -event.timestamp, event.serialize)
+        @storage.zremrangebyrank(storage_key, @history_length, -1)
+
+        if @global
+          @storage.zadd(global_events_storage_key, -event.timestamp, event.serialize)
+          @storage.zremrangebyrank(global_events_storage_key, @history_length, -1)
+        end
+      end
+
+      def log(event, *args)
+        return unless logging_enabled?
+
+        unless respond_to?(event)
+          raise ArgumentError, "Invalid log event: #{event}"
+        end
+
+        expected_arity = method(event).arity
+        unless args.count == expected_arity
+          raise(
+            ArgumentError,
+            "Invalid number of arguments for event '#{event}': expected #{expected_arity} but got #{args.count}",
+          )
+        end
+
+        public_send(event, *args)
+      end
+
+      CONTEXT_THREAD_KEY = :rollout_logging_context
+      WITHOUT_THREAD_KEY = :rollout_logging_disabled
+
+      def with_context(context)
+        raise ArgumentError, "context must be a Hash" unless context.is_a?(Hash)
+        raise ArgumentError, "block is required" unless block_given?
+
+        Thread.current[CONTEXT_THREAD_KEY] = context
+        yield
+      ensure
+        Thread.current[CONTEXT_THREAD_KEY] = nil
+      end
+
+      def current_context
+        Thread.current[CONTEXT_THREAD_KEY] || {}
+      end
+
+      def without
+        Thread.current[WITHOUT_THREAD_KEY] = true
+        yield
+      ensure
+        Thread.current[WITHOUT_THREAD_KEY] = nil
+      end
+
+      def logging_enabled?
+        !Thread.current[WITHOUT_THREAD_KEY]
+      end
+
+      private
+
+      def global_events_storage_key
+        "feature:_global_:logging:events"
+      end
+
+      def events_storage_key(feature_name)
+        "feature:#{feature_name}:logging:events"
+      end
+
+      def current_timestamp
+        (Time.now.to_f * 1_000_000).to_i
+      end
+    end
+  end
+end

data/lib/rollout/version.rb

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

data/lib/rollout.rb

@@ -1,18 +1,30 @@
 # frozen_string_literal: true
 
 require 'rollout/feature'
+require 'rollout/logging'
 require 'rollout/version'
 require 'zlib'
 require 'set'
 require 'json'
+require 'observer'
 
 class Rollout
+  include Observable
+
   RAND_BASE = (2**32 - 1) / 100.0
 
+  attr_reader :options, :storage
+
   def initialize(storage, opts = {})
     @storage = storage
     @options = opts
     @groups  = { all: ->(_user) { true } }
+
+    extend(Logging) if opts[:logging]
+  end
+
+  def groups
+    @groups.keys
   end
 
   def activate(feature)
@@ -30,6 +42,10 @@ class Rollout
     features.delete(feature.to_s)
     @storage.set(features_key, features.join(','))
     @storage.del(key(feature))
+
+    if respond_to?(:logging)
+      logging.delete(feature)
+    end
   end
 
   def set(feature, desired_state)
@@ -91,7 +107,7 @@ class Rollout
 
   def active?(feature, user = nil)
     feature = get(feature)
-    feature.active?(self, user)
+    feature.active?(user)
   end
 
   def user_in_active_users?(feature, user = nil)
@@ -122,7 +138,7 @@ class Rollout
 
   def get(feature)
     string = @storage.get(key(feature))
-    Feature.new(feature, string, @options)
+    Feature.new(feature, state: string, rollout: self, options: @options)
   end
 
   def set_feature_data(feature, data)
@@ -141,7 +157,13 @@ class Rollout
     return [] if features.empty?
 
     feature_keys = features.map { |feature| key(feature) }
-    @storage.mget(*feature_keys).map.with_index { |string, index| Feature.new(features[index], string, @options) }
+
+    @storage
+      .mget(*feature_keys)
+      .map
+      .with_index do |string, index|
+        Feature.new(features[index], state: string, rollout: self, options: @options)
+      end
   end
 
   def features
@@ -150,13 +172,13 @@ class Rollout
 
   def feature_states(user = nil)
     multi_get(*features).each_with_object({}) do |f, hash|
-      hash[f.name] = f.active?(self, user)
+      hash[f.name] = f.active?(user)
     end
   end
 
   def active_features(user = nil)
     multi_get(*features).select do |f|
-      f.active?(self, user)
+      f.active?(user)
     end.map(&:name)
   end
 
@@ -179,6 +201,21 @@ class Rollout
     end
   end
 
+  def with_feature(feature)
+    f = get(feature)
+
+    if count_observers > 0
+      before = f.deep_clone
+      yield(f)
+      save(f)
+      changed
+      notify_observers(:update, before, f)
+    else
+      yield(f)
+      save(f)
+    end
+  end
+
   private
 
   def key(name)
@@ -189,12 +226,6 @@ class Rollout
     'feature:__features__'
   end
 
-  def with_feature(feature)
-    f = get(feature)
-    yield(f)
-    save(f)
-  end
-
   def save(feature)
     @storage.set(key(feature.name), feature.serialize)
     @storage.set(features_key, (features | [feature.name.to_sym]).join(','))

data/rollout.gemspec

@@ -20,11 +20,11 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.3'
 
-  spec.add_dependency 'redis', '~> 4.0'
+  spec.add_dependency 'redis', '>= 4.0', '< 6'
 
   spec.add_development_dependency 'bundler', '>= 1.17'
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'rspec_junit_formatter', '~> 0.4'
   spec.add_development_dependency 'rubocop', '~> 0.71'
   spec.add_development_dependency 'simplecov', '0.17'

data/spec/rollout/feature_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe "Rollout::Feature" do
+  let(:rollout) { Rollout.new($redis) }
+
+  describe "#add_user" do
+    it "ids a user using id_user_by" do
+      user    = double("User", email: "test@test.com")
+      feature = Rollout::Feature.new(:chat, state: nil, rollout: rollout, options: { id_user_by: :email })
+      feature.add_user(user)
+      expect(user).to have_received :email
+    end
+  end
+
+  describe "#initialize" do
+    describe "when string does not exist" do
+      it 'clears feature attributes when string is not given' do
+        feature = Rollout::Feature.new(:chat, rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      it 'clears feature attributes when string is nil' do
+        feature = Rollout::Feature.new(:chat, state: nil, rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      it 'clears feature attributes when string is empty string' do
+        feature = Rollout::Feature.new(:chat, state: "", rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      describe "when there is no data" do
+        it 'sets @data to empty hash' do
+          feature = Rollout::Feature.new(:chat, state: "0||", rollout: rollout)
+          expect(feature.data).to eq({})
+        end
+
+        it 'sets @data to empty hash' do
+          feature = Rollout::Feature.new(:chat, state: "|||   ", rollout: rollout)
+          expect(feature.data).to eq({})
+        end
+      end
+    end
+  end
+end