rollout 2.4.3 → 2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c11b1c464e66f315ad7ee924ea7408a5c4bf2a6f
-  data.tar.gz: 16da6d26818429e62e4783533df17d9022380a46
+SHA256:
+  metadata.gz: f3b0e1f4a4548a07a24f4f7a8153b3a5515447f8bf967163603a02d3e6aebdf1
+  data.tar.gz: d43fa317667dab8ff6269ddc1635e3316aba6d531d1107a68069f1a19e5113dc
 SHA512:
-  metadata.gz: 4b7b1416e6ba291b67dbce4b5d67db30bbe494fbb31791f6435efe3280607abf17d64cf96210bbe113c6c9948ca8d50c25c0547b9870d0f652033b69cf412b00
-  data.tar.gz: 19e0b2bd04907cfe2f1b400ccb047b8320b35dddf85f1b76d607b5491340f0b3a63a20fdb2f30af138579a8e016accc4aa88549d32c4136c8a003fe2997ea318
+  metadata.gz: f356e92d026c71c207e9415481a547741b7d8e067e90bd27806d6f7f13e0657de93b41105666ffe91b8b6e83f37b7e512b09ea179f63da5ef07bdf5e5d405a77
+  data.tar.gz: 4014f08455bd9ecf3100d16cab73ff3bde34ffb4c40478e2dec0f2d6a535db48915d9aedd80ec3bcee3858c02d33f4669afd9d8ec5b5888cbe769ea4a8807f02

data/.circleci/config.yml

@@ -0,0 +1,119 @@
+version: 2.1
+
+workflows:
+  main:
+    jobs:
+      - ruby33
+      - ruby31
+      - ruby32
+      - ruby30
+      - ruby27
+      - ruby26
+      - ruby25
+      - ruby24
+
+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: cimg/ruby:2.7
+      - image: cimg/redis:7.2
+  ruby26:
+    docker:
+      - image: cimg/ruby:2.7
+      - image: cimg/redis:7.2
+  ruby25:
+    docker:
+      - image: cimg/ruby:2.7
+      - image: cimg/redis:7.2
+  ruby24:
+    docker:
+      - image: cimg/ruby:2.4
+      - image: cimg/redis:7.2
+
+commands:
+  test:
+    steps:
+      - run:
+          name: Bundle Install
+          command: bundle check --path vendor/bundle || bundle install
+
+      - run:
+          name: Run rspec
+          command: |
+            bundle exec rspec --format documentation --format RspecJunitFormatter --out test_results/rspec.xml
+
+jobs:
+  ruby33:
+    executor: ruby33
+    steps:
+      - checkout
+      - test
+
+      - run:
+          name: Report Test Coverage
+          command: |
+            wget https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 -O cc-test-reporter
+            chmod +x cc-test-reporter
+            ./cc-test-reporter format-coverage -t simplecov -o coverage/codeclimate.json coverage/.resultset.json
+            ./cc-test-reporter upload-coverage -i coverage/codeclimate.json
+
+      - store_test_results:
+          path: test_results
+
+  ruby32:
+    executor: ruby30
+    steps:
+      - checkout
+      - test
+
+  ruby31:
+    executor: ruby30
+    steps:
+      - checkout
+      - test
+
+  ruby30:
+    executor: ruby30
+    steps:
+      - checkout
+      - test
+
+  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/.gitignore

@@ -19,5 +19,6 @@ rdoc
 pkg
 *.gem
 gemfiles/*.lock
+.rspec_status
 
 ## PROJECT::SPECIFIC

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/LineLength:
+  Max: 120
+Metrics/MethodLength:
+  Max: 20
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -4,13 +4,13 @@ sudo: false
 services:
   - redis-server
 rvm:
-  - 2.4.1
-  - 2.3.1
+  - 2.6
+  - 2.5
+  - 2.4
+  - 2.3
   - 2.2
   - 2.1
-  - 2.0.0
-  - 1.9.3
-  - jruby-19mode
+  - 2.0
 env:
   - USE_REAL_REDIS=true
 gemfile:

data/Gemfile

@@ -1,3 +1,5 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -2,10 +2,10 @@
 
 Fast feature flags based on Redis.
 
-[![Build Status](https://travis-ci.org/fetlife/rollout.svg?branch=master)](https://travis-ci.org/fetlife/rollout)
-[![Code Climate](https://codeclimate.com/github/FetLife/rollout/badges/gpa.svg)](https://codeclimate.com/github/fetlife/rollout)
-[![Test Coverage](https://codeclimate.com/github/FetLife/rollout/badges/coverage.svg)](https://codeclimate.com/github/fetlife/rollout/coverage)
-[![Dependency Status](https://gemnasium.com/FetLife/rollout.svg)](https://gemnasium.com/fetlife/rollout)
+[![Gem Version](https://badge.fury.io/rb/rollout.svg)](https://badge.fury.io/rb/rollout)
+[![CircleCI](https://circleci.com/gh/fetlife/rollout.svg?style=svg)](https://circleci.com/gh/fetlife/rollout)
+[![Code Climate](https://codeclimate.com/github/FetLife/rollout/badges/gpa.svg)](https://codeclimate.com/github/FetLife/rollout)
+[![Test Coverage](https://codeclimate.com/github/FetLife/rollout/badges/coverage.svg)](https://codeclimate.com/github/FetLife/rollout/coverage)
 
 ## Install it
 
@@ -20,10 +20,18 @@ Initialize a rollout object. I assign it to a global var.
 ```ruby
 require 'redis'
 
-$redis   = Redis.new
+$redis = Redis.new
 $rollout = Rollout.new($redis)
 ```
 
+or even simpler
+
+```ruby
+require 'redis'
+$rollout = Rollout.new($redis) # Will use REDIS_URL env var or default redis url
+```
+
+
 Update data specific to a feature:
 
 ```ruby
@@ -71,6 +79,9 @@ Deactivate groups like this:
 $rollout.deactivate_group(:chat, :all)
 ```
 
+Groups need to be defined every time your app starts. The logic is not persisted
+anywhere.
+
 ## Specific Users
 
 You might want to let a specific user into a beta test or something. If that
@@ -98,7 +109,7 @@ $rollout.activate_percentage(:chat, 20)
 The algorithm for determining which users get let in is this:
 
 ```ruby
-CRC32(user.id) % 100_000 < percentage * 1_000
+CRC32(user.id) < (2**32 - 1) / 100.0 * percentage
 ```
 
 So, for 20%, users 0, 1, 10, 11, 20, 21, etc would be allowed in. Those users
@@ -150,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
@@ -169,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
@@ -176,6 +197,8 @@ This example would use the "development:feature:chat:groups" key.
 *   Python: https://github.com/asenchi/proclaim
 *   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/Rakefile

@@ -1,9 +1,7 @@
-begin
-  require "rspec/core/rake_task"
+# frozen_string_literal: true
 
-  RSpec::Core::RakeTask.new(:spec)
+require 'rspec/core/rake_task'
 
-  task default: :spec
-rescue LoadError
-  # no rspec available
-end
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/rollout/feature.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+class Rollout
+  class Feature
+    attr_accessor :groups, :users, :percentage, :data
+    attr_reader :name, :options
+
+    def initialize(name, rollout:, state: nil, options: {})
+      @name = name
+      @rollout = rollout
+      @options = options
+
+      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)
+        @data = raw_data.nil? || raw_data.strip.empty? ? {} : JSON.parse(raw_data)
+      else
+        clear
+      end
+    end
+
+    def serialize
+      "#{@percentage}|#{@users.to_a.join(',')}|#{@groups.to_a.join(',')}|#{serialize_data}"
+    end
+
+    def add_user(user)
+      id = user_id(user)
+      @users << id unless @users.include?(id)
+    end
+
+    def remove_user(user)
+      @users.delete(user_id(user))
+    end
+
+    def add_group(group)
+      @groups << group.to_sym unless @groups.include?(group.to_sym)
+    end
+
+    def remove_group(group)
+      @groups.delete(group.to_sym)
+    end
+
+    def clear
+      @groups = groups_from_string('')
+      @users = users_from_string('')
+      @percentage = 0
+      @data = {}
+    end
+
+    def active?(user)
+      if user
+        id = user_id(user)
+        user_in_percentage?(id) ||
+          user_in_active_users?(id) ||
+          user_in_active_group?(user)
+      else
+        @percentage == 100
+      end
+    end
+
+    def user_in_active_users?(user)
+      @users.include?(user_id(user))
+    end
+
+    def to_hash
+      {
+        percentage: @percentage,
+        groups: @groups,
+        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)
+      if user.is_a?(Integer) || user.is_a?(String)
+        user.to_s
+      else
+        user.send(id_user_by).to_s
+      end
+    end
+
+    def id_user_by
+      @options[:id_user_by] || :id
+    end
+
+    def user_in_percentage?(user)
+      Zlib.crc32(user_id_for_percentage(user)) < RAND_BASE * @percentage
+    end
+
+    def user_id_for_percentage(user)
+      if @options[:randomize_percentage]
+        user_id(user).to_s + @name.to_s
+      else
+        user_id(user)
+      end
+    end
+
+    def user_in_active_group?(user)
+      @groups.any? do |g|
+        @rollout.active_in_group?(g, user)
+      end
+    end
+
+    def serialize_data
+      return '' unless @data.is_a? Hash
+
+      @data.to_json
+    end
+
+    def users_from_string(raw_users)
+      users = (raw_users || '').split(',').map(&:to_s)
+      if @options[:use_sets]
+        users.to_set
+      else
+        users
+      end
+    end
+
+    def groups_from_string(raw_groups)
+      groups = (raw_groups || '').split(',').map(&:to_sym)
+      if @options[:use_sets]
+        groups.to_set
+      else
+        groups
+      end
+    end
+  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,3 +1,5 @@
+# frozen_string_literal: true
+
 class Rollout
-  VERSION = "2.4.3"
+  VERSION = '2.6.1'
 end