rollout 2.4.2 → 2.5.0

data/lib/rollout/feature.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+class Rollout
+  class Feature
+    attr_accessor :groups, :users, :percentage, :data
+    attr_reader :name, :options
+
+    def initialize(name, string = nil, opts = {})
+      @options = opts
+      @name    = name
+
+      if string
+        raw_percentage, raw_users, raw_groups, raw_data = string.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?(rollout, user)
+      if user
+        id = user_id(user)
+        user_in_percentage?(id) ||
+          user_in_active_users?(id) ||
+          user_in_active_group?(user, rollout)
+      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
+
+    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, rollout)
+      @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,198 @@
+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,
+        )
+      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.2"
+  VERSION = '2.5.0'
 end

data/rollout.gemspec

@@ -1,27 +1,31 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rollout/version"
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name        = "rollout"
-  s.version     = Rollout::VERSION
-  s.authors     = ["James Golick"]
-  s.email       = ["jamesgolick@gmail.com"]
-  s.description = "Feature flippers with redis."
-  s.summary     = "Feature flippers with redis."
-  s.homepage    = "https://github.com/FetLife/rollout"
-  s.license     = "MIT"
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'rollout/version'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+Gem::Specification.new do |spec|
+  spec.name        = 'rollout'
+  spec.version     = Rollout::VERSION
+  spec.authors     = ['James Golick']
+  spec.email       = ['jamesgolick@gmail.com']
+  spec.description = 'Feature flippers with redis.'
+  spec.summary     = 'Feature flippers with redis.'
+  spec.homepage    = 'https://github.com/FetLife/rollout'
+  spec.license     = 'MIT'
 
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "appraisal"
-  s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "redis"
-  s.add_development_dependency "fakeredis"
-  s.add_development_dependency "simplecov"
-  s.add_development_dependency "codeclimate-test-reporter"
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_dependency 'redis', '~> 4.0'
+
+  spec.add_development_dependency 'bundler', '>= 1.17'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.4'
+  spec.add_development_dependency 'rubocop', '~> 0.71'
+  spec.add_development_dependency 'simplecov', '0.17'
 end

data/spec/rollout/logging_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+RSpec.describe 'Rollout::Logging' do
+  let(:rollout) { Rollout.new(Redis.current, logging: logging) }
+  let(:logging) { true }
+  let(:feature) { :foo }
+
+  it 'logs changes' do
+    expect(rollout.logging.last_event(feature)).to be_nil
+
+    rollout.activate_percentage(feature, 50)
+
+    expect(rollout.logging.updated_at(feature)).to_not be_nil
+
+    first_event = rollout.logging.last_event(feature)
+
+    expect(first_event.name).to eq 'update'
+    expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 50 })
+
+    rollout.activate_percentage(feature, 75)
+
+    second_event = rollout.logging.last_event(feature)
+
+    expect(second_event.name).to eq 'update'
+    expect(second_event.data).to eq(before: { percentage: 50 }, after: { percentage: 75 })
+
+    rollout.activate_group(feature, :hipsters)
+
+    third_event = rollout.logging.last_event(feature)
+
+    expect(third_event.name).to eq 'update'
+    expect(third_event.data).to eq(before: { groups: [] }, after: { groups: ['hipsters'] })
+
+    expect(rollout.logging.events(feature)).to eq [first_event, second_event, third_event]
+  end
+
+  context 'logging data changes' do
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature)).to be_nil
+
+      rollout.set_feature_data(feature, description: "foo")
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event).not_to be_nil
+      expect(event.name).to eq 'update'
+      expect(event.data).to eq(before: { "data.description": nil }, after: { "data.description": "foo" })
+    end
+  end
+
+  context 'no logging' do
+    let(:logging) { nil }
+
+    it 'doesnt even respond to logging' do
+      expect(rollout).not_to respond_to :logging
+    end
+  end
+
+  context 'history truncation' do
+    let(:logging) { { history_length: 1 } }
+
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature)).to be_nil
+
+      rollout.activate_percentage(feature, 25)
+
+      first_event = rollout.logging.last_event(feature)
+
+      expect(first_event.name).to eq 'update'
+      expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+
+      rollout.activate_percentage(feature, 30)
+
+      second_event = rollout.logging.last_event(feature)
+
+      expect(second_event.name).to eq 'update'
+      expect(second_event.data).to eq(before: { percentage: 25 }, after: { percentage: 30 })
+
+      expect(rollout.logging.events(feature)).to eq [second_event]
+    end
+  end
+
+  context 'with context' do
+    let(:current_user) { double(nickname: 'lester') }
+
+    it 'adds context to the event' do
+      rollout.logging.with_context(actor: current_user.nickname) do
+        rollout.activate_percentage(feature, 25)
+      end
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event.name).to eq 'update'
+      expect(event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+      expect(event.context).to eq(actor: current_user.nickname)
+    end
+  end
+
+  context 'global logs' do
+    let(:logging) { { global: true } }
+    let(:feature_foo) { 'foo' }
+    let(:feature_bar) { 'bar' }
+
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature_foo)).to be_nil
+
+      rollout.activate_percentage(feature_foo, 25)
+
+      event_foo = rollout.logging.last_event(feature_foo)
+
+      expect(event_foo.feature).to eq feature_foo
+      expect(event_foo.name).to eq 'update'
+      expect(event_foo.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+
+      expect(rollout.logging.events(feature_foo)).to eq [event_foo]
+
+      rollout.activate_percentage(feature_bar, 30)
+
+      event_bar = rollout.logging.last_event(feature_bar)
+
+      expect(event_bar.feature).to eq feature_bar
+      expect(event_bar.name).to eq 'update'
+      expect(event_bar.data).to eq(before: { percentage: 0 }, after: { percentage: 30 })
+
+      expect(rollout.logging.events(feature_bar)).to eq [event_bar]
+
+      expect(rollout.logging.global_events).to eq [event_foo, event_bar]
+    end
+  end
+
+  context 'no logging for block' do
+    it 'doesnt log' do
+      rollout.logging.without do
+        rollout.activate_percentage(feature, 25)
+      end
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event).to be_nil
+    end
+  end
+end
+