fluidfeatures-rails 0.1.0

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.swp
+.bundle
+Gemfile.lock
+pkg/*
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fluidfeatures.gemspec
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+fluidfeatures-rails
+===================
+
+Rails client for API of FluidFeatures.com

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+namespace :test do
+  Rake::TestTask.new(:all) do |t|
+    t.libs << "test"
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = true
+  end
+end

data/fluidfeatures-rails.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fluidfeatures/rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fluidfeatures-rails"
+  s.version     = FluidFeatures::Rails::VERSION
+  s.authors     = ["Phil Whelan"]
+  s.email       = ["phil@fluidfeatures.com"]
+  s.homepage    = "https://github.com/BigFastSite/fluidfeatures-rails"
+  s.summary     = %q{Ruby on Rails client for the FluidFeatures service.}
+  s.description = %q{Ruby on Rails client for the FluidFeatures service.}
+  s.rubyforge_project = s.name
+  s.files         = `git ls-files`.split("\n")
+  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_dependency "rails", "~>3.0"
+  s.add_dependency "persistent_http", "~>1.0.3"
+end

data/lib/fluidfeatures/rails/version.rb

@@ -0,0 +1,5 @@
+module FluidFeatures
+  module Rails
+    VERSION = '0.1.0'
+  end
+end

data/lib/fluidfeatures/rails.rb

@@ -0,0 +1,288 @@
+
+require 'rails'
+require 'net/http'
+require 'persistent_http'
+
+#
+# Without these FluidFeatures credentials we cannot talk to
+# the FluidFeatures service.
+#
+%w[FLUIDFEATURES_BASEURI FLUIDFEATURES_SECRET FLUIDFEATURES_APPID].each do |key|
+  unless ENV[key]
+    raise "Environment variable #{key} expected"
+  end
+end
+
+module FluidFeatures
+  module Rails
+    
+    #
+    # This is called once, when your Rails application fires up.
+    # It sets up the before and after request hooks
+    #
+    def self.initializer
+      ::Rails::Application.initializer "fluidfeatures.initializer" do
+        ActiveSupport.on_load(:action_controller) do
+
+          @@baseuri = ENV["FLUIDFEATURES_BASEURI"]
+          @@secret = ENV["FLUIDFEATURES_SECRET"]
+          @@app_id = ENV["FLUIDFEATURES_APPID"]
+          @@http = PersistentHTTP.new(
+            :name         => 'fluidfeatures',
+            :logger       => ::Rails.logger,
+            :pool_size    => 10,
+            :warn_timeout => 0.25,
+            :force_retry  => true,
+            :url          => @@baseuri
+          )
+          @@unknown_features = {}
+          @@last_fetch_duration = nil
+
+          ActionController::Base.append_before_filter :fluidfeatures_request_init
+          ActionController::Base.append_after_filter :fluidfeatures_store_features_hit
+
+        end
+      end
+    end
+    
+    #
+    # This can be used to control how much of your user-base sees a
+    # particular feature. It may be easier to use the dashboard provided
+    # at https://www.fluidfeatures.com/dashboard to manage this, or to
+    # set timers to automate the gradual rollout of your new features.
+    #
+    def self.feature_set_enabled_percent(feature_name, enabled_percent)
+      begin
+        uri = URI(@@baseuri + "/app/" + @@app_id.to_s + "/features/" + feature_name.to_s)
+        request = Net::HTTP::Put.new uri.path
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        request['AUTHORIZATION'] = @@secret
+        payload = {
+          :enabled => {
+            :percent => enabled_percent
+          }
+        }
+        request.body = JSON.dump(payload)
+        response = @@http.request uri, request
+        if response.is_a?(Net::HTTPSuccess)
+          ::Rails.logger.error "[" + response.code.to_s + "] Failed to set feature enabled percent : " + uri.to_s + " : " + response.body.to_s
+        end
+      rescue
+        ::Rails.logger.error "Request to set feature enabled percent failed : " + uri.to_s
+        raise
+      end
+    end
+
+    #
+    # Returns all the features that FluidFeatures knows about for
+    # your application. The enabled percentage (how much of your user-base)
+    # sees each feature is also provided.
+    #
+    def self.get_feature_set
+      features = nil
+      begin
+        uri = URI(@@baseuri + "/app/" + @@app_id.to_s + "/features")
+        request = Net::HTTP::Get.new uri.path
+        request["Accept"] = "application/json"
+        request['AUTHORIZATION'] = @@secret
+        response = @@http.request request
+        if response.is_a?(Net::HTTPSuccess)
+          features = JSON.parse(response.body)
+        end
+      rescue
+        ::Rails.logger.error "Request failed when getting feature set from " + uri.to_s
+        raise
+      end
+      if not features
+        ::Rails.logger.error "Empty feature set returned from " + uri.to_s
+      end
+      features
+    end
+
+    #
+    # Returns all the features enabled for a specific user.
+    # This will depend on the user_id and how many users each
+    # feature is enabled for.
+    #
+    def self.get_user_features(user_id)
+      if not user_id
+        raise "user_id is not given for get_user_features"
+      end
+      features = {}
+      fetch_start_time = Time.now
+      begin
+        uri = URI(@@baseuri + "/app/" + @@app_id.to_s + "/user/" + user_id.to_s + "/features")
+        request = Net::HTTP::Get.new uri.path
+        request["Accept"] = "application/json"
+        request['AUTHORIZATION'] = @@secret
+        response = @@http.request request
+        if response.is_a?(Net::HTTPSuccess)
+          features = JSON.parse(response.body)
+        else
+          ::Rails.logger.error "[" + response.code.to_s + "] Failed to get user features : " + uri.to_s + " : " + response.body.to_s
+        end
+      rescue
+        ::Rails.logger.error "Request to get user features failed : " + uri.to_s
+        raise
+      end
+      @@last_fetch_duration = Time.now - fetch_start_time
+      features
+    end
+    
+    #
+    # This is called when we encounter a feature_name that
+    # FluidFeatures has no record of for your application.
+    # This will be reported back to the FluidFeatures service so
+    # that it can populate your dashboard with this feature.
+    # The parameter "default_enabled" is a boolean that says whether
+    # this feature should be enabled to all users or no users.
+    # Usually, this is "true" for existing features that you are
+    # planning to phase out and "false" for new feature that you
+    # intend to phase in.
+    #
+    def self.unknown_feature_hit(feature_name, version_name, defaults)
+      if not @@unknown_features[feature_name]
+        @@unknown_features[feature_name] = { :versions => {} }
+      end
+      @@unknown_features[feature_name][:versions][version_name] = defaults
+    end
+    
+    #
+    # This reports back to FluidFeatures which features we
+    # encountered during this request, the request duration,
+    # and statistics on time spent talking to the FluidFeatures
+    # service. Any new features encountered will also be reported
+    # back with the default_enabled status (see unknown_feature_hit)
+    # so that FluidFeatures can auto-populate the dashboard.
+    #
+    def self.log_features_hit(user_id, features_hit, request_duration)
+      begin
+        uri = URI(@@baseuri + "/app/" + @@app_id.to_s + "/user/" + user_id.to_s + "/features/hit")
+        request = Net::HTTP::Post.new uri.path
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        request['AUTHORIZATION'] = @@secret
+        payload = {
+          :stats => {
+            :fetch => {
+              :duration => @@last_fetch_duration
+            },
+            :request => {
+              :duration => request_duration
+            }
+          },
+          :features => {
+            :hit => features_hit
+          }
+        }
+        if @@unknown_features.size
+          payload[:features][:unknown] = @@unknown_features
+          @@unknown_features = {}
+        end
+        request.body = JSON.dump(payload)
+        response = @@http.request request
+        unless response.is_a?(Net::HTTPSuccess)
+          ::Rails.logger.error "[" + response.code.to_s + "] Failed to log features hit : " + uri.to_s + " : " + response.body.to_s
+        end
+      rescue Exception => e
+        ::Rails.logger.error "Request to log user features hit failed : " + uri.to_s
+        raise
+      end
+    end
+    
+  end
+end
+
+module ActionController
+  class Base
+    
+    #
+    # Here is how we know what your user_id is for the user
+    # making the current request.
+    # This must be overriden within the user application.
+    # We recommend doing this in application_controller.rb
+    #
+    def fluidfeatures_set_user_id(user_id)
+      @ff_user_id = user_id
+    end
+    
+    #
+    # This is called by the developer's code to determine if the
+    # feature, specified by "feature_name" is enabled for the
+    # current user.
+    # We call user_id to get the current user's unique id.
+    #
+    def fluidfeature(feature_name, defaults={})
+      @features_hit ||= []
+      @features_hit << feature_name
+      if defaults === true or defaults === false
+        defaults = { :enabled => defaults }
+      end
+      global_defaults = fluidfeatures_defaults || {}
+      version = (defaults[:version] || global_defaults[:version]).to_s
+      if not @features
+        fluidfeatures_retrieve_user_features
+      end
+      if @features.has_key? feature_name
+        if @features[feature_name].is_a? FalseClass or @features[feature_name].is_a? TrueClass
+          enabled = @features[feature_name]
+        elsif @features[feature_name].is_a? Hash
+          if @features[feature_name].has_key? version
+            enabled = @features[feature_name][version]
+          end
+        end
+      end
+      if enabled === nil
+        enabled = defaults[:enabled] || global_defaults[:enabled]
+        
+        # Tell FluidFeatures about this amazing new feature...
+        options = Hash.new(defaults)
+        options[:enabled] = enabled
+        options[:version] = version
+        ::Rails.logger.error "fluidfeature: #{feature_name.to_s} #{version}"
+        FluidFeatures::Rails.unknown_feature_hit(feature_name, version, options)
+      end
+      enabled
+    end
+
+    #
+    # Initialize the FluidFeatures state for this request.
+    #
+    def fluidfeatures_request_init
+      @ff_request_start_time = Time.now
+      @features = nil
+    end
+    
+    #
+    # Returns the features enabled for this request's user.
+    #
+    def fluidfeatures_retrieve_user_features
+      @features = FluidFeatures::Rails.get_user_features(@ff_user_id)
+    end
+     
+    #
+    # After the rails request is complete we will log which features we
+    # encountered, including the default settings (eg. enabled) for each
+    # feature.
+    # This helps the FluidFeatures database prepopulate the feature set
+    # without requiring the developer to do it manually.
+    # 
+    def fluidfeatures_store_features_hit
+      if @features
+        request_duration = Time.now - @ff_request_start_time
+        FluidFeatures::Rails.log_features_hit(@ff_user_id, @features_hit, request_duration)
+      end
+    end
+    
+    def fluidfeatures_defaults
+      # By default unknown features are disabled.
+      {
+        :enabled => false,
+        :version => 1
+      }
+    end
+
+  end
+end
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: fluidfeatures-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Phil Whelan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: persistent_http
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+description: Ruby on Rails client for the FluidFeatures service.
+email:
+- phil@fluidfeatures.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- fluidfeatures-rails.gemspec
+- lib/fluidfeatures/rails.rb
+- lib/fluidfeatures/rails/version.rb
+homepage: https://github.com/BigFastSite/fluidfeatures-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fluidfeatures-rails
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby on Rails client for the FluidFeatures service.
+test_files: []