fluidfeatures 0.3.0 → 0.3.1

data/lib/fluidfeatures/app/feature.rb

@@ -0,0 +1,44 @@
+
+require "fluidfeatures/const"
+
+module FluidFeatures
+  class AppFeatureVersion
+    
+    attr_accessor :app, :feature_name, :version_name
+    
+    DEFAULT_VERSION_NAME = "default"
+  
+    def initialize(app, feature_name, version_name=DEFAULT_VERSION_NAME)
+
+      raise "app invalid : #{app}" unless app.is_a? FluidFeatures::App
+      raise "feature_name invalid : #{feature_name}" unless feature_name.is_a? String
+      version_name ||= ::FluidFeatures::DEFAULT_VERSION_NAME
+      raise "version_name invalid : #{version_name}" unless version_name.is_a? String
+
+      @app = client
+      @feature_name = feature_name
+      @version_name = version_name
+
+    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.
+    #
+    def set_enabled_percent(percent)
+
+      unless percent.is_a? Numeric and percent >= 0.0 and percent <= 100.0
+        raise "percent invalid : #{percent}"
+      end
+
+      app.put("/feature/#{feature_name}/#{version_name}/enabled/percent", {
+        :enabled => {
+          :percent => enabled_percent
+        }
+      })
+    end
+
+  end
+end
+

data/lib/fluidfeatures/app/user.rb

@@ -0,0 +1,180 @@
+
+require "fluidfeatures/const"
+
+module FluidFeatures
+  class AppUser
+    
+    attr_accessor :app, :unique_id, :display_name, :anonymous, :unique_attrs, :cohort_attrs
+    
+    def initialize(app, user_id, display_name, is_anonymous, unique_attrs, cohort_attrs)
+
+      raise "app invalid : #{app}" unless app.is_a? FluidFeatures::App
+
+      @app = app
+      @unique_id = user_id
+      @display_name = display_name
+      @anonymous = is_anonymous
+      @unique_attrs = unique_attrs
+      @cohort_attrs = cohort_attrs
+
+      @features = nil
+      @features_hit = {}
+      @goals_hit = {}
+      @unknown_features = {}
+
+      if not unique_id or is_anonymous
+
+        # We're an anonymous user
+        @anonymous = true
+
+        # if we were not given a user[:id] for this anonymous user, then get
+        # it from an existing cookie or create a new one.
+        unless unique_id
+          # Create new unique id (for cookie). Use rand + micro-seconds of current time
+          @unique_id = "anon-" + Random.rand(9999999999).to_s + "-" + ((Time.now.to_f * 1000000).to_i % 1000000).to_s
+        end
+      end
+
+    end
+
+    #
+    # Returns all the features enabled for a specific user.
+    # This will depend on the user's unique_id and how many
+    # users each feature is enabled for.
+    #
+    def load_features
+
+      # extract just attribute ids into simple hash
+      attribute_ids = {
+        :anonymous => anonymous
+      }
+      [unique_attrs, cohort_attrs].each do |attrs|
+        if attrs
+          attrs.each do |attr_key, attr|
+            if attr.is_a? Hash
+              if attr.has_key? :id
+                attribute_ids[attr_key] = attr[:id]
+              end
+            else
+              attribute_ids[attr_key] = attr
+            end
+          end
+        end
+      end
+
+      # normalize attributes ids as strings
+      attribute_ids.each do |attr_key, attr_id|
+        if attr_id.is_a? FalseClass or attr_id.is_a? TrueClass
+          attribute_ids[attr_key] = attr_id.to_s.downcase
+        elsif not attr_id.is_a? String
+          attribute_ids[attr_key] = attr_id.to_s
+        end
+      end
+
+      app.get("/user/#{unique_id}/features", attribute_ids) || {}
+    end
+
+    def features
+      @features ||= load_features
+    end
+
+    def feature_enabled?(feature_name, version_name, default_enabled)
+
+      raise "feature_name invalid : #{feature_name}" unless feature_name.is_a? String
+      version_name ||= ::FluidFeatures::DEFAULT_VERSION_NAME
+
+      if features.has_key? feature_name
+        feature = features[feature_name]
+        if feature.is_a? Hash
+          if feature.has_key? version_name
+            enabled = feature[version_name]
+          end
+        end
+      end
+
+      if enabled === nil
+        enabled = default_enabled
+        
+        # Tell FluidFeatures about this amazing new feature...
+        unknown_feature_hit(feature_name, version_name, default_enabled)
+      end
+
+      if enabled
+        @features_hit[feature_name] ||= {}
+        @features_hit[feature_name][version_name.to_s] = {}
+      end
+
+      enabled
+    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 unknown_feature_hit(feature_name, version_name, default_enabled)
+      if not @unknown_features[feature_name]
+        @unknown_features[feature_name] = { :versions => {} }
+      end
+      @unknown_features[feature_name][:versions][version_name] = default_enabled
+    end
+
+    def goal_hit(goal_name, goal_version_name)
+      sleep 10
+      raise "goal_name invalid : #{goal_name}" unless goal_name.is_a? String
+      goal_version_name ||= ::FluidFeatures::DEFAULT_VERSION_NAME
+      raise "goal_version_name invalid : #{goal_version_name}" unless goal_version_name.is_a? String
+      @goals_hit[goal_name.to_s] ||= {}
+      @goals_hit[goal_name.to_s][goal_version_name.to_s] = {}
+    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 end_transaction(url, stats)
+
+      payload = {
+        :url => url,
+        :user => {
+          :id => unique_id
+        },
+        :hits => {
+          :feature => @features_hit,
+          :goal    => @goals_hit
+        }
+      }
+
+      if stats
+        raise "stats invalid : #{stats}" unless stats.is_a? Hash
+        payload[:stats] = stats
+      end
+
+      payload_user = payload[:user] ||= {}
+      payload_user[:name] = display_name if display_name
+      payload_user[:anonymous] = anonymous if anonymous
+      payload_user[:unique] = unique_attrs if unique_attrs
+      payload_user[:cohorts] = cohort_attrs if cohort_attrs
+      
+      (payload[:stats] ||= {})[:ff_latency] = app.client.last_fetch_duration
+      if @unknown_features.size
+        (payload[:features] ||= {})[:unknown] = @unknown_features
+        @unknown_features = {}
+      end
+      
+      app.post("/user/#{unique_id}/features/hit", payload)
+
+    end
+
+  end
+end

data/lib/fluidfeatures/app.rb

@@ -0,0 +1,53 @@
+
+require "fluidfeatures/app/user"
+require "fluidfeatures/app/feature"
+
+module FluidFeatures
+  class App
+    
+    attr_accessor :client, :app_id, :secret, :logger
+    
+    def initialize(client, app_id, secret, logger)
+
+      raise "client invalid : #{client}" unless client.is_a? FluidFeatures::Client
+      raise "app_id invalid : #{app_id}" unless app_id.is_a? String
+      raise "secret invalid : #{secret}" unless secret.is_a? String
+
+      @client = client
+      @app_id = app_id
+      @secret = secret
+      @logger = logger
+
+    end
+
+    def get(path, params=nil)
+      client.get("/app/#{app_id}#{path}", secret, params)
+    end
+
+    def put(path, payload)
+      client.put("/app/#{app_id}#{path}", secret, payload)
+    end
+
+    def post(path, payload)
+      client.post("/app/#{app_id}#{path}", secret, payload)
+    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 features
+      get("/features")
+    end
+
+    def user(user_id, display_name, is_anonymous, unique_attrs, cohort_attrs)
+      ::FluidFeatures::AppUser.new(self, user_id, display_name, is_anonymous, unique_attrs, cohort_attrs)
+    end
+    
+    def feature_version(feature_name, version_name)
+      ::FluidFeatures::AppFeatureVersion.new(self, feature_name, version_name)
+    end
+
+  end
+end

data/lib/fluidfeatures/client.rb

@@ -1,204 +1,97 @@
 
-require "logger"
+require 'net/http'
+require 'persistent_http'
+require "pre_ruby192/uri" if RUBY_VERSION < "1.9.2"
 
-if RUBY_VERSION < "1.9.2"
-  require "pre_ruby192/uri"
-end
+require "fluidfeatures/app"
 
 module FluidFeatures
   class Client
 
-    attr_accessor :logger
-
-    def initialize(base_uri, app_id, secret, options={})
+    attr_accessor :base_uri, :logger, :last_fetch_duration
 
-      @logger = options[:logger] || ::Logger.new(STDERR)
+    def initialize(base_uri, logger)
 
-      @baseuri = base_uri
-      @app_id = app_id
-      @secret = secret
+      @logger = logger
+      @base_uri = base_uri
 
-      @http = PersistentHTTP.new(
+      @http = ::PersistentHTTP.new(
         :name         => 'fluidfeatures',
-        :logger       => @logger,
+        :logger       => logger,
         :pool_size    => 10,
         :warn_timeout => 0.25,
         :force_retry  => true,
-        :url          => @baseuri
+        :url          => base_uri
       )
 
-      @unknown_features = {}
       @last_fetch_duration = nil
 
     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 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)
-          logger.error{"[FF] [" + response.code.to_s + "] Failed to set feature enabled percent : " + uri.to_s + " : " + response.body.to_s}
+    def get(path, auth_token, url_params=nil)
+      payload = nil
+
+      uri = URI(@base_uri + path)
+      url_path = uri.path
+      if url_params
+        uri.query = URI.encode_www_form( url_params )
+        if uri.query
+          url_path += "?" + uri.query
         end
-      rescue
-        logger.error{"[FF] 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 get_feature_set
-      features = nil
       begin
-        uri = URI(@baseuri + "/app/" + @app_id.to_s + "/features")
-        request = Net::HTTP::Get.new uri.path
+        request = Net::HTTP::Get.new url_path
         request["Accept"] = "application/json"
-        request['AUTHORIZATION'] = @secret
+        request['AUTHORIZATION'] = auth_token
+        fetch_start_time = Time.now
         response = @http.request request
         if response.is_a?(Net::HTTPSuccess)
-          features = JSON.parse(response.body)
+          payload = JSON.parse(response.body)
+          @last_fetch_duration = Time.now - fetch_start_time
         end
       rescue
-        logger.error{"[FF] Request failed when getting feature set from " + uri.to_s}
+        logger.error{"[FF] Request failed when getting #{path}"}
         raise
       end
-      if not features
-        logger.error{"[FF] Empty feature set returned from " + uri.to_s}
+      if not payload
+        logger.error{"[FF] Empty response from #{path}"}
       end
-      features
+      payload
     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 get_user_features(user)
-      logger.debug{"[FF] get_user_features #{user}"}
-      if not user
-        raise "user object should be a Hash"
-      end
-      if not user[:id]
-        raise "user does not contain :id field"
-      end
-
-      # extract just attribute ids into simple hash
-      attribute_ids = {
-        :anonymous => !!user[:anonymous]
-      }
-      [:unique, :cohorts].each do |attr_type|
-        if user.has_key? attr_type
-          user[attr_type].each do |attr_key, attr|
-            if attr.is_a? Hash
-              if attr.has_key? :id
-                attribute_ids[attr_key] = attr[:id]
-              end
-            else
-              attribute_ids[attr_key] = attr
-            end
-          end
-        end
-      end
-
-      # normalize attributes ids as strings
-      attribute_ids.each do |attr_key, attr_id|
-        if attr_id.is_a? FalseClass or attr_id.is_a? TrueClass
-          attribute_ids[attr_key] = attr_id.to_s.downcase
-        elsif not attr_id.is_a? String
-          attribute_ids[attr_key] = attr_id.to_s
-        end
-      end
-
-      features = {}
-      fetch_start_time = Time.now
+    def put(path, auth_token, payload)
       begin
-        uri = URI("#{@baseuri}/app/#{@app_id}/user/#{user[:id]}/features")
-        uri.query = URI.encode_www_form( attribute_ids )
-        url_path = uri.path
-        if uri.query
-          url_path += "?" + uri.query
-        end
-        request = Net::HTTP::Get.new url_path
+        uri = URI(@base_uri + path)
+        request = Net::HTTP::Put.new uri.path
+        request["Content-Type"] = "application/json"
         request["Accept"] = "application/json"
-        request['AUTHORIZATION'] = @secret
-        response = @http.request request
-        if response.is_a?(Net::HTTPSuccess)
-          features = JSON.parse(response.body)
-        else
-          logger.error{"[FF] [#{response.code}] Failed to get user features : #{uri} : #{response.body}"}
+        request['AUTHORIZATION'] = auth_token
+        request.body = JSON.dump(payload)
+        response = @http.request uri, request
+        unless response.is_a?(Net::HTTPSuccess)
+          logger.error{"[FF] Request unsuccessful when putting #{path}"}
         end
-      rescue
-        logger.error{"[FF] Request to get user features failed : #{uri}"}
+      rescue Exception => err
+        logger.error{"[FF] Request failed putting #{path} : #{err.message}"}
         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 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 log_request(user_id, payload)
+
+    def post(path, auth_token, payload)
       begin
-        (payload[:stats] ||= {})[:ff_latency] = @last_fetch_duration
-        if @unknown_features.size
-          (payload[:features] ||= {})[:unknown] = @unknown_features
-          @unknown_features = {}
-        end
-        uri = URI(@baseuri + "/app/#{@app_id}/user/#{user_id}/features/hit")
+        uri = URI(@base_uri + path)
         request = Net::HTTP::Post.new uri.path
         request["Content-Type"] = "application/json"
         request["Accept"] = "application/json"
-        request['AUTHORIZATION'] = @secret
+        request['AUTHORIZATION'] = auth_token
         request.body = JSON.dump(payload)
         response = @http.request request
         unless response.is_a?(Net::HTTPSuccess)
-          logger.error{"[FF] [" + response.code.to_s + "] Failed to log features hit : " + uri.to_s + " : " + response.body.to_s}
+          logger.error{"[FF] Request unsuccessful when posting #{path}"}
         end
-      rescue Exception => e
-        logger.error{"[FF] Request to log user features hit failed : " + uri.to_s}
+      rescue Exception => err
+        logger.error{"[FF] Request failed posting #{path} : #{err.message}"}
         raise
       end
     end

data/lib/fluidfeatures/const.rb

@@ -0,0 +1,4 @@
+
+module FluidFeatures
+  DEFAULT_VERSION_NAME = "default"
+end

data/lib/fluidfeatures/version.rb

@@ -1,3 +1,3 @@
 module FluidFeatures
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/lib/fluidfeatures.rb

@@ -0,0 +1,15 @@
+
+require "logger"
+
+require "fluidfeatures/client"
+require "fluidfeatures/app"
+
+module FluidFeatures
+  
+  def self.app(base_uri, app_id, secret, logger=nil)
+    logger ||= ::Logger.new(STDERR)
+    client = ::FluidFeatures::Client.new(base_uri, logger)
+    ::FluidFeatures::App.new(client, app_id, secret, logger)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluidfeatures
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -38,7 +38,12 @@ files:
 - Gemfile
 - README.md
 - fluidfeatures.gemspec
+- lib/fluidfeatures.rb
+- lib/fluidfeatures/app.rb
+- lib/fluidfeatures/app/feature.rb
+- lib/fluidfeatures/app/user.rb
 - lib/fluidfeatures/client.rb
+- lib/fluidfeatures/const.rb
 - lib/fluidfeatures/version.rb
 - lib/pre_ruby192/uri.rb
 homepage: https://github.com/FluidFeatures/fluidfeatures-ruby