fluidfeatures 0.3.1 → 0.3.4

data/LICENSE

@@ -0,0 +1,46 @@
+
+All components of this product are
+Copyright (c) 2012 FluidFeatures Software Inc.  All rights reserved.
+
+FluidFeatures Software License
+
+This Software and all content and other materials in the Software or associated
+with the Software, including, without limitation, all logos, and all designs,
+text, graphics, pictures, reviews, information, data, software, sound files,
+other files and the selection and arrangement thereof (collectively, the
+"Software Materials") are the proprietary property of FluidFeatures Software
+Inc., or its licensors or users, and are protected by Canada, U.S. and
+international copyright laws.
+
+You are granted a limited, non-sublicensable license to access and use the
+Software, for your commercial use by you and your website users only. The
+license does not include or authorize: (a) any resale of the Software or the
+Software Materials therein; (b) modifying or otherwise making any derivative
+uses of the Software and the Software Materials, or any portion thereof, except
+where such modification or derivative use is made in connection with your use of
+the FluidFeatures online service; or (c) any use of the Software or the Software
+Materials other than for its intended purpose. Any use of the Software or the
+Software Materials other than as specifically authorized in these license,
+without the prior written permission of FluidFeatures Software Inc, is strictly
+prohibited and will terminate the license granted here. Such unauthorized use
+may also violate applicable laws including without limitation copyright and
+trademark laws and applicable communications regulations and statutes. Unless
+explicitly stated herein, nothing in this license shall be construed as
+conferring any license to intellectual property rights, whether by estoppel,
+implication or otherwise.  This license is revocable at any time for any reason.
+
+THE SOFTWARE AND THE SOFTWARE MATERIALS (INCLUDING ANY INFORMATION) ARE PROVIDED
+ON AN "AS IS" AND "AS AVAILABLE" BASIS WITHOUT WARRANTIES OF ANY KIND, EITHER
+EXPRESS OR IMPLIED, AND INCLUDING WITHOUT LIMITATION IMPLIED REPRESENTATIONS,
+WARRANTIES OR CONDITIONS OF OR RELATING TO ACCURACY, ACCESSIBILITY,
+AVAILABILITY, COMPLETENESS, ERRORS, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY, NON-INFRINGEMENT, PERFORMANCE, QUALITY, RESULTS, SECURITY,
+SEQUENCE, OR TIMELINESS, ALL OF WHICH ARE HEREBY DISCLAIMED BY FLUIDFEATURES
+SOFTWARE INC TO THE FULLEST EXTENT PERMITTED BY LAW.
+
+THE AGGREGATE LIABILITY OF FLUID FEATURES SOFTWARE INC. TO YOU, WHETHER IN
+CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE, WHETHER ACTIVE, PASSIVE OR
+IMPUTED), PRODUCT LIABILITY, STRICT LIABILITY OR OTHER THEORY OF LIABILITY,
+SHALL NOT EXCEED ANY COMPENSATION YOU PAY, IF ANY, FOR ACCESS TO OR USE OF THE
+SOFTWARE.
+

data/fluidfeatures.gemspec

@@ -14,4 +14,5 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.require_paths = ["lib"]
   s.add_dependency "persistent_http", "~>1.0.3"
+  s.add_dependency "uuid", "~>2.3.5"
 end

data/lib/fluidfeatures/app/reporter.rb

@@ -0,0 +1,274 @@
+
+require "fluidfeatures/const"
+require "thread"
+
+module FluidFeatures
+  class AppReporter
+    
+    attr_accessor :app
+    
+    # Throw away oldest buckets when this limit reached.
+    MAX_BUCKETS = 10
+
+    # Max number of transactions we queue in a bucket.
+    MAX_BUCKET_SIZE = 100
+
+    # While queue is empty we will check size every 0.5 secs
+    WAIT_BETWEEN_QUEUE_EMTPY_CHECKS = 0.5 # seconds
+
+    # Soft max of 1 req/sec
+    WAIT_BETWEEN_SEND_SUCCESS_NONE_WAITING = 1 # seconds
+
+    # Hard max of 10 req/sec
+    WAIT_BETWEEN_SEND_SUCCESS_NEXT_WAITING = 0.1 # seconds
+
+    # If we are failing to communicate with the FluidFeautres API
+    # then wait for this long between requests.
+    WAIT_BETWEEN_SEND_FAILURES = 5 # seconds
+    
+    def initialize(app)
+
+      raise "app invalid : #{app}" unless app.is_a? ::FluidFeatures::App
+
+      @app = app
+
+      @buckets = []
+      @buckets_lock = ::Mutex.new
+
+      @current_bucket = nil
+      @current_bucket_lock = ::Mutex.new
+      @current_bucket = new_bucket
+
+      @unknown_features = {}
+      @unknown_features_lock = ::Mutex.new
+
+      run_transcation_sender
+
+    end
+
+    # Pass FluidFeatures::AppTransaction for reporting back to the
+    # FluidFeatures service.
+    def report_transaction(transaction)
+
+      user = transaction.user
+
+      payload = {
+        :url => transaction.url,
+        :user => {
+          :id => user.unique_id
+        },
+        :hits => {
+          :feature => transaction.features_hit,
+          :goal    => transaction.goals_hit
+        },
+        # stats
+        :stats => {
+          :duration => transaction.duration
+        }
+      }
+
+      payload_user = payload[:user] ||= {}
+      payload_user[:name] = user.display_name if user.display_name
+      payload_user[:anonymous] = user.anonymous if user.anonymous
+      payload_user[:unique] = user.unique_attrs if user.unique_attrs
+      payload_user[:cohorts] = user.cohort_attrs if user.cohort_attrs
+
+      queue_transaction_payload(payload)
+
+      if transaction.unknown_features.size > 0
+        queue_unknown_features(transaction.unknown_features)
+      end
+
+    end
+
+    def run_transcation_sender
+      Thread.new do
+        while true
+          begin
+
+            unless transactions_queued?
+              sleep WAIT_BETWEEN_QUEUE_EMTPY_CHECKS
+              next
+            end
+
+            success = send_transcations
+
+            if success
+              # Unless we have a full bucket waiting do not make
+              # more than N requests per second.
+              if bucket_count <= 1
+                sleep WAIT_BETWEEN_SEND_SUCCESS_NONE_WAITING
+              else
+                sleep WAIT_BETWEEN_SEND_SUCCESS_NEXT_WAITING
+              end
+            else  
+              # If service is down, then slow our requests
+              # within this thread
+              sleep WAIT_BETWEEN_SEND_FAILURES
+            end
+
+          rescue Exception => err
+            # catch errors, so that we do not affect the rest of the application
+            app.logger.error "[FF] send_transcations failed : #{err.message}\n#{err.backtrace.join("\n")}"
+            # hold off for a little while and try again
+            sleep WAIT_BETWEEN_SEND_FAILURES
+          end
+        end
+      end
+    end
+
+    @private
+    def transactions_queued?
+      have_transactions = false
+      @buckets_lock.synchronize do
+        if @buckets.size == 1
+          @current_bucket_lock.synchronize do
+            if @current_bucket.size > 0
+              have_transactions = true
+            end
+          end
+        elsif @buckets.size > 1 and @buckets[0].size > 0
+          have_transactions = true
+        end
+      end
+      have_transactions
+    end
+
+    @private
+    def send_transcations
+      bucket = remove_bucket
+      
+      ff_latency = app.client.last_fetch_duration
+
+      # Take existing unknown features and reset
+      unknown_features = nil
+      @unknown_features_lock.synchronize do
+        unknown_features = @unknown_features
+        @unknown_features = {}
+      end
+
+      remaining_buckets_stats = nil
+      @buckets_lock.synchronize do
+        remaining_buckets_stats = @buckets.map { |b| b.size }
+      end
+
+      api_request_log = app.client.siphon_api_request_log
+
+      payload = {
+        :client_uuid => app.client.uuid,
+        :transactions => bucket,
+        :stats => {
+          :ff_latency => ff_latency,
+          :waiting_buckets => remaining_buckets_stats
+        },
+        :unknown_features => unknown_features,
+        :api_request_log => api_request_log
+      }
+
+      if remaining_buckets_stats.size > 0
+        payload[:stats][:waiting_buckets] = remaining_buckets_stats
+      end
+
+      # attempt to send to fluidfeatures service
+      success = app.post("/report/transactions", payload)
+
+      # handle failure to send data
+      unless success
+        # return bucket into bucket queue until the next attempt at sending
+        if not unremove_bucket(bucket)
+          app.logger.warn "[FF] Discarded #{discarded_bucket.size} transactions due to reporter backlog. These will not be reported to FluidFeatures."
+        end
+        # return unknown features to queue until the next attempt at sending
+        queue_unknown_features(unknown_features)
+      end
+
+      # return whether we were able to send or not
+      success
+    end
+
+    @private
+    def bucket_count
+      num_buckets = 0
+      @buckets_lock.synchronize do
+        num_buckets = @buckets.size
+      end
+      num_buckets
+    end
+      
+    @private
+    def new_bucket
+      bucket = []
+      discarded_bucket = nil
+      @buckets_lock.synchronize do
+        @buckets << bucket
+        if @buckets.size > MAX_BUCKETS
+          discarded_bucket = @buckets.shift
+        end
+      end
+      if discarded_bucket
+        app.logger.warn "[FF] Discarded #{discarded_bucket.size} transactions due to reporter backlog. These will not be reported to FluidFeatures."
+      end
+      bucket
+    end
+
+    @private
+    def remove_bucket
+      removed_bucket = nil
+      @buckets_lock.synchronize do
+        if @buckets.size > 0
+          removed_bucket = @buckets.shift
+        end
+        if @buckets.size == 0
+          @current_bucket_lock.synchronize do
+            @current_bucket = []
+            @buckets << @current_bucket
+          end
+        end
+      end
+      removed_bucket
+    end
+
+    @private
+    def unremove_bucket(bucket)
+      success = false
+      @buckets_lock.synchronize do
+        if @buckets.size <= MAX_BUCKETS
+          @buckets.unshift bucket
+          success = true
+        end
+      end
+      success
+    end
+
+    @private
+    def queue_transaction_payload(transaction_payload)
+      @current_bucket_lock.synchronize do
+        if @current_bucket.size >= MAX_BUCKET_SIZE
+          @current_bucket = new_bucket
+        end
+        @current_bucket << transaction_payload
+      end
+    end
+
+    @private
+    def queue_unknown_features(unknown_features)
+      raise "unknown_features should be a Hash" unless unknown_features.is_a? Hash
+      unknown_features.each_pair do |feature_name, versions|
+        raise "unknown_features values should be Hash. versions=#{versions}" unless versions.is_a? Hash
+      end
+      @unknown_features_lock.synchronize do
+        unknown_features.each_pair do |feature_name, versions|
+          unless @unknown_features.has_key? feature_name
+            @unknown_features[feature_name] = {}
+          end
+          versions.each_pair do |version_name, default_enabled|
+            unless @unknown_features[feature_name].has_key? version_name
+              @unknown_features[feature_name][version_name] = default_enabled
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/fluidfeatures/app/state.rb

@@ -0,0 +1,150 @@
+
+require "digest/sha1"
+require "set"
+require "thread"
+
+require "fluidfeatures/const"
+require "fluidfeatures/app/transaction"
+
+module FluidFeatures
+  class AppState
+    
+    attr_accessor :app
+    USER_ID_NUMERIC = Regexp.compile("^\d+$")
+    
+    # Request to FluidFeatures API to long-poll for max
+    # 30 seconds. The API may choose a different duration.
+    # If not change in this time, API will return HTTP 304.
+    ETAG_WAIT = ENV["FF_DEV"] ? 5 : 30
+
+    # Hard max of 2 req/sec
+    WAIT_BETWEEN_FETCH_SUCCESS = 0.5 # seconds
+
+    # Hard max of 10 req/sec
+    WAIT_BETWEEN_SEND_SUCCESS_NEXT_WAITING = 0.1 # seconds
+
+    # If we are failing to communicate with the FluidFeautres API
+    # then wait for this long between requests.
+    WAIT_BETWEEN_FETCH_FAILURES = 5 # seconds
+
+    def initialize(app)
+
+      raise "app invalid : #{app}" unless app.is_a? FluidFeatures::App
+
+      @app = app
+      @features = {}
+      @features_lock = ::Mutex.new
+
+      run_state_fetcher
+
+    end
+
+    def features
+      f = nil
+      @features_lock.synchronize do
+        f = @features
+      end
+      f
+    end
+
+    def features= f
+      return unless f.is_a? Hash
+      @features_lock.synchronize do
+        @features = f
+      end
+    end
+
+    def run_state_fetcher
+      Thread.new do
+        while true
+          begin
+
+            success, state = load_state
+
+            # Note, success could be true, but state might be nil.
+            # This occurs with 304 (no change)
+            if success and state
+              # switch out current state with new one
+              self.features = state
+            elsif not success
+              # If service is down, then slow our requests
+              # within this thread
+              sleep WAIT_BETWEEN_FETCH_FAILURES
+            end
+
+            # What ever happens never make more than N requests
+            # per second
+            sleep WAIT_BETWEEN_FETCH_SUCCESS
+
+          rescue Exception => err
+            # catch errors, so that we do not affect the rest of the application
+            app.logger.error "load_state failed : #{err.message}\n#{err.backtrace.join("\n")}"
+            # hold off for a little while and try again
+            sleep WAIT_BETWEEN_FETCH_FAILURES
+          end
+        end
+      end
+    end
+
+    def load_state
+      success, state = app.get("/features", { :verbose => true, :etag_wait => ETAG_WAIT }, true)
+      if success and state
+        state.each_pair do |feature_name, feature|
+          feature["versions"].each_pair do |version_name, version|
+            # convert parts to a Set for quick lookup
+            version["parts"] = Set.new(version["parts"] || [])
+          end
+        end
+      end
+      return success, state
+    end
+
+    def feature_version_enabled_for_user(feature_name, version_name, user_id, user_attributes={})
+      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
+
+      #assert(isinstance(user_id, basestring))
+      
+      user_attributes ||= {}
+      user_attributes["user"] = user_id.to_s
+      if user_id.is_a? Integer
+        user_id_hash = user_id
+      elsif USER_ID_NUMERIC.match(user_id)
+        user_id_hash = user_id.to_i
+      else
+        user_id_hash = Digest::SHA1.hexdigest(user_id)[-10, 10].to_i(16)
+      end
+      enabled = false
+
+      feature = features[feature_name]
+      version = feature["versions"][version_name]
+      modulus = user_id_hash % feature["num_parts"]
+      enabled = version["parts"].include? modulus
+
+      # check attributes
+      feature["versions"].each_pair do |other_version_name, other_version|
+        if other_version
+          version_attributes = (other_version["enabled"] || {})["attributes"]
+          if version_attributes
+            user_attributes.each_pair do |attr_key, attr_id|
+              version_attribute = version_attributes[attr_key.to_s]
+              if version_attribute and version_attribute.include? attr_id.to_s
+                if other_version_name == version_name
+                  # explicitly enabled for this version
+                  return true
+                else
+                  # explicitly enabled for another version
+                  return false
+                end
+              end
+            end
+          end
+        end
+      end
+
+      enabled
+    end
+
+  end
+end

data/lib/fluidfeatures/app/transaction.rb

@@ -0,0 +1,110 @@
+
+require "fluidfeatures/const"
+
+module FluidFeatures
+  class AppUserTransaction
+    
+    attr_accessor :user, :url, :features, :start_time, :ended, :features_hit, :goals_hit, :unknown_features
+
+    def initialize(user, url)
+
+      @user = user
+      @url  = url
+
+      # take a snap-shot of the features end at
+      # the beginning of the transaction
+      @features = user.features
+
+      @features_hit = {}
+      @goals_hit = {}
+      @unknown_features = {}
+      @start_time = Time.now
+      @ended = false
+
+    end
+
+    def feature_enabled?(feature_name, version_name, default_enabled)
+      raise "transaction ended" if ended
+      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)
+      raise "transaction ended" if ended
+      unless @unknown_features.has_key? feature_name
+        @unknown_features[feature_name] = {}
+      end
+      unless @unknown_features[feature_name].has_key? version_name
+        @unknown_features[feature_name][version_name] = default_enabled
+      end
+    end
+
+    def goal_hit(goal_name, goal_version_name)
+      raise "transaction ended" if ended
+      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
+
+    def duration
+      if ended
+        @duration
+      else
+        Time.now - start_time
+      end
+    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
+
+      raise "transaction already ended" if ended
+      @ended = true
+      @duration = Time.now - start_time
+      user.app.reporter.report_transaction(self)
+    end
+
+  end
+end

data/lib/fluidfeatures/app/user.rb

@@ -1,5 +1,6 @@
 
 require "fluidfeatures/const"
+require "fluidfeatures/app/transaction"
 
 module FluidFeatures
   class AppUser
@@ -8,7 +9,7 @@ module FluidFeatures
     
     def initialize(app, user_id, display_name, is_anonymous, unique_attrs, cohort_attrs)
 
-      raise "app invalid : #{app}" unless app.is_a? FluidFeatures::App
+      raise "app invalid : #{app}" unless app.is_a? ::FluidFeatures::App
 
       @app = app
       @unique_id = user_id
@@ -17,11 +18,6 @@ module FluidFeatures
       @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
@@ -37,12 +33,20 @@ module FluidFeatures
 
     end
 
+    def get(path, params=nil)
+      app.get("/user/#{unique_id}#{path}", params)
+    end
+
+    def post(path, payload)
+      app.post("/user/#{unique_id}#{path}", payload)
+    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
+    def features
 
       # extract just attribute ids into simple hash
       attribute_ids = {
@@ -71,109 +75,28 @@ module FluidFeatures
         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]
+      if ENV["FLUIDFEATURES_USER_FEATURES_FROM_API"]
+        features_enabled = get("/features", attribute_ids) || {}
+      else
+        features_enabled = {}
+        app.state.features.each do |feature_name, feature|
+          feature["versions"].keys.each do |version_name|
+            features_enabled[feature_name] ||= {}
+            features_enabled[feature_name][version_name] = \
+              app.state.feature_version_enabled_for_user(
+                feature_name,
+                version_name,
+                unique_id,
+                attribute_ids
+              )
           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] = {}
+      features_enabled
     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)
-
+    def transaction(url)
+      ::FluidFeatures::AppUserTransaction.new(self, url)
     end
 
   end

data/lib/fluidfeatures/app.rb

@@ -1,11 +1,13 @@
 
 require "fluidfeatures/app/user"
 require "fluidfeatures/app/feature"
+require "fluidfeatures/app/state"
+require "fluidfeatures/app/reporter"
 
 module FluidFeatures
   class App
     
-    attr_accessor :client, :app_id, :secret, :logger
+    attr_accessor :client, :app_id, :secret, :state, :reporter, :logger
     
     def initialize(client, app_id, secret, logger)
 
@@ -17,11 +19,13 @@ module FluidFeatures
       @app_id = app_id
       @secret = secret
       @logger = logger
+      @state = ::FluidFeatures::AppState.new(self)
+      @reporter = ::FluidFeatures::AppReporter.new(self)
 
     end
 
-    def get(path, params=nil)
-      client.get("/app/#{app_id}#{path}", secret, params)
+    def get(path, params=nil, cache=false)
+      client.get("/app/#{app_id}#{path}", secret, params, cache)
     end
 
     def put(path, payload)
@@ -44,6 +48,10 @@ module FluidFeatures
     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 user_transaction(user_id, url, display_name, is_anonymous, unique_attrs, cohort_attrs)
+      user(user_id, display_name, is_anonymous, unique_attrs, cohort_attrs).transaction(url)
+    end
     
     def feature_version(feature_name, version_name)
       ::FluidFeatures::AppFeatureVersion.new(self, feature_name, version_name)

data/lib/fluidfeatures/client.rb

@@ -1,17 +1,22 @@
 
-require 'net/http'
-require 'persistent_http'
+require "net/http"
+require "persistent_http"
 require "pre_ruby192/uri" if RUBY_VERSION < "1.9.2"
+require "thread"
+require "uuid"
 
 require "fluidfeatures/app"
 
 module FluidFeatures
   class Client
 
-    attr_accessor :base_uri, :logger, :last_fetch_duration
+    attr_accessor :uuid, :base_uri, :logger, :last_fetch_duration
+
+    API_REQUEST_LOG_MAX_SIZE = 200
 
     def initialize(base_uri, logger)
 
+      @uuid = UUID.new.generate
       @logger = logger
       @base_uri = base_uri
 
@@ -24,11 +29,41 @@ module FluidFeatures
         :url          => base_uri
       )
 
-      @last_fetch_duration = nil
+      @api_request_log = []
+      @api_request_log_lock = ::Mutex.new
+
+      @etags = {}
+      @etags_lock = ::Mutex.new
+
+    end
+
+    def log_api_request(method, url, duration, status_code, err_msg)
+      @api_request_log_lock.synchronize do
+        @api_request_log << {
+          :method => method,
+          :url => url,
+          :duration => duration,
+          :status => status_code,
+          :err => err_msg,
+          :time => Time.now.to_f.round(2)
+        }
+        # remove older entry if too big
+        if @api_request_log.size > API_REQUEST_LOG_MAX_SIZE
+          @api_request_log.shift
+        end
+      end
+    end
 
+    def siphon_api_request_log
+      request_log = nil
+      @api_request_log_lock.synchronize do
+        request_log = @api_request_log
+        @api_request_log = []
+      end
+      request_log
     end
 
-    def get(path, auth_token, url_params=nil)
+    def get(path, auth_token, url_params=nil, cache=false)
       payload = nil
 
       uri = URI(@base_uri + path)
@@ -40,60 +75,144 @@ module FluidFeatures
         end
       end
 
+      duration = nil
+      status_code = nil
+      err_msg = nil
+      no_change = false
+      success = false
       begin
+
         request = Net::HTTP::Get.new url_path
         request["Accept"] = "application/json"
         request['AUTHORIZATION'] = auth_token
-        fetch_start_time = Time.now
+        @etags_lock.synchronize do
+          if cache and @etags.has_key? url_path
+            request["If-None-Match"] = @etags[url_path][:etag]
+          end
+        end
+
+        request_start_time = Time.now
         response = @http.request request
-        if response.is_a?(Net::HTTPSuccess)
-          payload = JSON.parse(response.body)
-          @last_fetch_duration = Time.now - fetch_start_time
+        duration = Time.now - request_start_time
+
+        if response.is_a? Net::HTTPResponse
+          status_code = response.code
+          if response.is_a? Net::HTTPNotModified
+            no_change = true
+            success = true
+          elsif response.is_a? Net::HTTPSuccess
+            payload = JSON.load(response.body) rescue nil
+            if cache
+              @etags_lock.synchronize do
+                @etags[url_path] = {
+                  :etag => response["Etag"],
+                  :time => Time.now
+                }
+              end
+            end
+            success = true
+          else
+            payload = JSON.load(response.body) rescue nil
+            if payload and payload.is_a? Hash and payload.has_key? "error"
+              err_msg = payload["error"]
+            end
+            logger.error{"[FF] Request unsuccessful for GET #{path} : #{response.class} #{status_code} #{err_msg}"}
+          end
         end
+      rescue PersistentHTTP::Error => err
+        logger.error{"[FF] Request failed for GET #{path} : #{err.message}"}
       rescue
-        logger.error{"[FF] Request failed when getting #{path}"}
+        logger.error{"[FF] Request failed for GET #{path} : #{status_code} #{err_msg}"}
         raise
+      else
+        unless no_change or payload
+          logger.error{"[FF] Empty response for GET #{path} : #{status_code} #{err_msg}"}
+        end
       end
-      if not payload
-        logger.error{"[FF] Empty response from #{path}"}
-      end
-      payload
+
+      log_api_request("GET", url_path, duration, status_code, err_msg)
+
+      return success, payload
     end
 
     def put(path, auth_token, payload)
+      uri = URI(@base_uri + path)
+      url_path = uri.path
+      duration = nil
+      status_code = nil
+      err_msg = nil
+      success = false
       begin
-        uri = URI(@base_uri + path)
-        request = Net::HTTP::Put.new uri.path
+        request = Net::HTTP::Put.new uri_path
         request["Content-Type"] = "application/json"
         request["Accept"] = "application/json"
         request['AUTHORIZATION'] = auth_token
         request.body = JSON.dump(payload)
+
+        request_start_time = Time.now
         response = @http.request uri, request
-        unless response.is_a?(Net::HTTPSuccess)
-          logger.error{"[FF] Request unsuccessful when putting #{path}"}
+        duration = Time.now - request_start_time
+
+        raise "expected Net::HTTPResponse" if not response.is_a? Net::HTTPResponse
+        status_code = response.code
+        if response.is_a? Net::HTTPSuccess
+          success = true
+        else
+          response_payload = JSON.load(response.body) rescue nil
+          if response_payload.is_a? Hash and response_payload.has_key? "error"
+            err_msg = response_payload["error"]
+          end
+          logger.error{"[FF] Request unsuccessful for PUT #{path} : #{status_code} #{err_msg}"}
         end
+      rescue PersistentHTTP::Error => err
+        logger.error{"[FF] Request failed for PUT #{path} : #{err.message}"}
       rescue Exception => err
-        logger.error{"[FF] Request failed putting #{path} : #{err.message}"}
+        logger.error{"[FF] Request failed for PUT #{path} : #{err.message}"}
         raise
       end
+
+      log_api_request("PUT", url_path, duration, status_code, err_msg)
+      return success
     end
 
     def post(path, auth_token, payload)
+      uri = URI(@base_uri + path)
+      url_path = uri.path
+      duration = nil
+      status_code = nil
+      err_msg = nil
+      success = false
       begin
-        uri = URI(@base_uri + path)
-        request = Net::HTTP::Post.new uri.path
+        request = Net::HTTP::Post.new url_path
         request["Content-Type"] = "application/json"
         request["Accept"] = "application/json"
         request['AUTHORIZATION'] = auth_token
         request.body = JSON.dump(payload)
+
+        request_start_time = Time.now
         response = @http.request request
-        unless response.is_a?(Net::HTTPSuccess)
-          logger.error{"[FF] Request unsuccessful when posting #{path}"}
+        duration = Time.now - request_start_time
+
+        raise "expected Net::HTTPResponse" if not response.is_a? Net::HTTPResponse
+        status_code = response.code
+        if response.is_a? Net::HTTPSuccess
+          success = true
+        else
+          response_payload = JSON.load(response.body) rescue nil
+          if response_payload.is_a? Hash and response_payload.has_key? "error"
+            err_msg = response_payload["error"]
+          end
+          logger.error{"[FF] Request unsuccessful for POST #{path} : #{status_code} #{err_msg}"}
         end
+      rescue PersistentHTTP::Error => err
+        logger.error{"[FF] Request failed for POST #{path} : #{err.message}"}
       rescue Exception => err
-        logger.error{"[FF] Request failed posting #{path} : #{err.message}"}
+        logger.error{"[FF] Request failed for POST #{path} : #{err.message}"}
         raise
       end
+
+      log_api_request("POST", url_path, duration, status_code, err_msg)
+      return success
     end
 
   end

data/lib/fluidfeatures/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluidfeatures
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-31 00:00:00.000000000 Z
+date: 2012-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: persistent_http
@@ -27,6 +27,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.5
 description: Ruby client for the FluidFeatures service.
 email:
 - phil@fluidfeatures.com
@@ -36,11 +52,15 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- LICENSE
 - README.md
 - fluidfeatures.gemspec
 - lib/fluidfeatures.rb
 - lib/fluidfeatures/app.rb
 - lib/fluidfeatures/app/feature.rb
+- lib/fluidfeatures/app/reporter.rb
+- lib/fluidfeatures/app/state.rb
+- lib/fluidfeatures/app/transaction.rb
 - lib/fluidfeatures/app/user.rb
 - lib/fluidfeatures/client.rb
 - lib/fluidfeatures/const.rb
@@ -66,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fluidfeatures
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Ruby client for the FluidFeatures service.