rollout 2.4.6 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3e6e9521ed03059b5b673616e985f89231d77d1ca42d8fa7ff00797ef906768
-  data.tar.gz: ac66f6f5f0da7e03bbf506d09f62d34e6afd7f1ea09b248b5193d74f3b6a720e
+  metadata.gz: 37e56080ba30fb08aaa7e718e22fae3cab0745e84a91537e4e5520c2843a63a2
+  data.tar.gz: 2b2f8c5a6e7a3ddd8275d818b4a168e7573204c2e259e323ca7a2ea9996062d9
 SHA512:
-  metadata.gz: ccebf1c2024c332cd921a49b400a7ee8e9a5c0ce95cdf59f5e89fb302bef08684cc04ffae30c952e14ffd5acc97d583871ee590aebe6aa2c519cc416afc17b9f
-  data.tar.gz: fe0a400d1f694a6aefb5b1e7d89afb64a8cb28c07a1f510d01655d724bfb97d5b38e7c60e40669aec5fded5581e760549b53564078018cad92c968b6900753ee
+  metadata.gz: a31905463a16ca7413566460c9a693ab5b9063e74547c05aafe2cf40d5e8f8d83ecb9e85316dd48c3e6b5e5b63311ac222343b485228a695ff5b72f8b0d82a2c
+  data.tar.gz: 33fc542bdfe0def2b13a1b3697ba59c1e5f83e813a7c67740d94bf0a9725e17003fdc3fecfa923874883730dde589e0906b5d49ab19ff49c36943e259c28f134

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)
@@ -179,6 +195,21 @@ class Rollout
     end
   end
 
+  def with_feature(feature)
+    f = get(feature)
+
+    if count_observers > 0
+      before = Marshal.load(Marshal.dump(f))
+      yield(f)
+      save(f)
+      changed
+      notify_observers(:update, before, f)
+    else
+      yield(f)
+      save(f)
+    end
+  end
+
   private
 
   def key(name)
@@ -189,12 +220,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/lib/rollout/feature.rb

@@ -67,7 +67,8 @@ class Rollout
       {
         percentage: @percentage,
         groups: @groups,
-        users: @users
+        users: @users,
+        data: @data,
       }
     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,5 +1,5 @@
 # frozen_string_literal: true
 
 class Rollout
-  VERSION = '2.4.6'
+  VERSION = '2.5.0'
 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
+

data/spec/rollout_spec.rb

@@ -429,7 +429,8 @@ RSpec.describe "Rollout" do
       expect(feature.to_hash).to eq(
         groups: [:caretakers, :greeters],
         percentage: 10,
-        users: %w(42)
+        users: %w(42),
+        data: {},
       )
 
       feature = @rollout.get(:signup)
@@ -449,7 +450,8 @@ RSpec.describe "Rollout" do
       expect(feature.to_hash).to eq(
         groups: [:caretakers, :greeters].to_set,
         percentage: 10,
-        users: %w(42).to_set
+        users: %w(42).to_set,
+        data: {},
       )
 
       feature = @rollout.get(:signup)
@@ -473,7 +475,8 @@ RSpec.describe "Rollout" do
         expect(@rollout.get(feature).to_hash).to eq(
           percentage: 0,
           users: [],
-          groups: []
+          groups: [],
+          data: {},
         )
       end
     end
@@ -485,7 +488,8 @@ RSpec.describe "Rollout" do
         expect(@rollout.get(feature).to_hash).to eq(
           percentage: 0,
           users: Set.new,
-          groups: Set.new
+          groups: Set.new,
+          data: {},
         )
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollout
 version: !ruby/object:Gem::Version
-  version: 2.4.6
+  version: 2.5.0
 platform: ruby
 authors:
 - James Golick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-12 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -126,8 +126,10 @@ files:
 - Rakefile
 - lib/rollout.rb
 - lib/rollout/feature.rb
+- lib/rollout/logging.rb
 - lib/rollout/version.rb
 - rollout.gemspec
+- spec/rollout/logging_spec.rb
 - spec/rollout_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/FetLife/rollout
@@ -149,10 +151,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Feature flippers with redis.
-test_files:
-- spec/rollout_spec.rb
-- spec/spec_helper.rb
+test_files: []