keen 0.0.53 → 0.1.0

data/features/add_event.feature

@@ -0,0 +1,10 @@
+# Language: en
+Feature: AddEvent
+  In order to send an event to Keen's servers
+  As a developer
+  I want to be able to post an event to the Keen Client as a Hash/Dictionary
+
+  Scenario: Send Event directly to Keen
+    Given a Keen Client using Direct
+    When I post an event
+    Then the response from the server should be good.

data/features/redis_queue.feature

@@ -0,0 +1,34 @@
+# Language: en
+Feature: RedisHandler
+  In order to make fewer than n HTTP connections for n events
+  As a developer
+  I want to be able to batch up events in Redis and send them to Keen all at once.
+
+  Scenario Outline: Add Events to Redis queue
+    Given a Keen Client using Redis
+    When I post <n> events
+    Then the size of the Redis queue should have gone up by <n>.
+
+    Examples:
+      |n    | 
+      |1    | 
+      |100  | 
+      |99   | 
+      |1000 | 
+      |999  | 
+
+  Scenario Outline: Batch a bunch of events in the Redis queue, then send them.
+    Given a Keen Client using Redis
+    When I post <n> events
+    And I process the queue
+    Then the response from Keen should be <n> happy smiles
+    And the queue should be empty.
+
+    Examples:
+      |n    | 
+      |1    | 
+      |100  | 
+      |99   | 
+      |1000 | 
+      |999  | 
+

data/features/step_definitions/keen_steps.rb

@@ -0,0 +1,61 @@
+begin require 'rspec/expectations'; rescue LoadError; require 'spec/expectations'; end
+require 'cucumber/formatter/unicode'
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'keen'
+
+Given /^a Keen Client using Redis$/ do
+  @client = Keen::Client.new(@project_id, 
+                             @auth_token, 
+                             :storage_class => Keen::Async::Storage::RedisHandler,
+                             :storage_namespace => "test",
+                             :logging => false )
+
+  @client.storage_handler.clear_active_queue
+
+  @starting_queue_size = @client.storage_handler.count_active_queue
+end
+
+Given /^a Keen Client using Direct$/ do
+  @client = Keen::Client.new(@project_id, 
+                             @auth_token, 
+                             :cache_locally => false,
+                             :logging => false )
+end
+
+When /^I post an event$/ do
+  @result = @client.add_event("cucumber_events", {:hi_from => "cucumber!", :keen_version => Keen::VERSION})
+end
+
+Then /^the size of the Redis queue should have gone up by (\d+)\.$/ do |n|
+  @client.storage_handler.count_active_queue.should == n.to_i + @starting_queue_size
+end
+
+Then /^the response from the server should be good\.$/ do
+  response = @result
+  response.should == {"created" => true}
+end
+
+
+When /^I post (\d+) events$/ do |n|
+  n.to_i.times do
+    @client.add_event("cucumber_events", {:hi_from => "cucumber!", :keen_version => Keen::VERSION})
+  end
+end
+
+When /^I process the queue$/ do
+  worker = Keen::Async::Worker.new(@client)
+  @result = worker.process_queue
+end
+
+Then /^the response from Keen should be (\d+) happy smiles$/ do |n|
+  expectation = []
+  n.to_i.times do
+    expectation.push({"success" => true})
+  end
+
+  expectation = {"cucumber_events" => expectation}
+end
+
+Then /^the queue should be empty\.$/ do
+  @client.storage_handler.count_active_queue.should == 0
+end

data/features/support/before_and_after.rb

@@ -0,0 +1,4 @@
+Before do |scenario|
+  @project_id = Keen::TEST_PROJECT_ID
+  @auth_token = Keen::TEST_AUTH_TOKEN
+end

data/keen.gemspec

@@ -23,17 +23,14 @@ Gem::Specification.new do |s|
   # s.add_runtime_dependency "rest-client"
   
   s.add_dependency('json', '>= 1.6.5')
-  s.add_dependency('fakeweb', '>= 1.3.0')
   s.add_dependency('rspec', '>= 2.9.0')
+  s.add_dependency('cucumber', '>= 1.2.1')
+
+  # This is no longer necessary, since we support several storage modes now:
+  # s.add_dependency('redis', '>= 2.2.2')
+
   if RUBY_VERSION < "1.9"
     s.add_dependency('system_timer', '>= 1.2.4')
   end
-  s.add_dependency('redis', '>= 2.2.2')
 
-  # took these from Twilio library:
-  # TODO clean this up.
-  #s.add_development_dependency 'rake',    '~> 0.9.0'
-  #s.add_development_dependency 'rspec',   '~> 2.6.0'
-  #s.add_development_dependency 'fakeweb', '~> 1.3.0'
-  #s.add_development_dependency 'rack',    '~> 1.3.0'
 end

data/lib/keen.rb

@@ -1,6 +1,6 @@
+require 'keen/async'
 require 'keen/client'
-require 'keen/version'
+require 'keen/event'
+require 'keen/keys'
 require 'keen/utils'
-require 'keen/async/job'
-require 'keen/async/worker'
-require 'keen/async/storage/redis_handler'
+require 'keen/version'

data/lib/keen/async.rb

@@ -0,0 +1,6 @@
+require 'keen/async/storage/base_storage_handler'
+require 'keen/async/storage/redis_handler'
+require 'keen/async/storage/flat_file_handler'
+require 'keen/async/job'
+require 'keen/async/worker'
+

data/lib/keen/async/job.rb

@@ -7,7 +7,7 @@ module Keen
       #
       #
 
-      attr_accessor :project_id, :auth_token, :collection_name, :event_body
+      attr_accessor :project_id, :auth_token, :collection_name, :event_body, :timestamp
       
       def to_json(options=nil)
         @definition.to_json
@@ -18,8 +18,8 @@ module Keen
         self.to_json
       end
       
-      def initialize(handler, definition={})
-
+      def initialize(handler, definition)
+        # The `definition` can come from redis, a flat file, or code.
         load_definition(definition)
         @handler = handler
         
@@ -30,7 +30,7 @@ module Keen
         definition = Keen::Utils.symbolize_keys(definition)
 
         # define some key lists:
-        required_keys = [:project_id, :auth_token, :collection_name, :event_body]
+        required_keys = [:timestamp, :project_id, :auth_token, :collection_name, :event_body]
         optional_keys = [:keen_client_version]
         all_keys = required_keys + optional_keys
 
@@ -43,6 +43,11 @@ module Keen
 
 
         required_keys.each do |key|
+          
+          unless definition.has_key? key
+            raise "You failed to send: #{key} -- you sent #{JSON.generate definition}"
+          end
+
           value = definition[key]
 
           raise "You sent a nil value for the #{key}." if value.nil?

data/lib/keen/async/storage/base_storage_handler.rb

@@ -0,0 +1,51 @@
+require 'json'
+require 'time'
+
+module Keen
+  module Async
+    module Storage
+      class BaseStorageHandler
+
+        def initialize(client)
+          @logging = client.options[:logging]
+          @client = client
+        end
+
+        # Key stuff
+        # ----
+
+        def global_key_prefix
+          "keen.#{@client.options[:storage_namespace]}"
+        end
+        
+        def active_queue_key
+          "#{global_key_prefix}.active_queue"
+        end
+
+        def failed_queue_key
+          "#{global_key_prefix}.failed_queue"
+        end
+
+        def add_to_active_queue(value)
+          @redis.lpush active_queue_key, value
+          if @logging
+            puts "added #{value} to active queue; length is now #{@redis.llen active_queue_key}"
+          end
+        end
+
+        def record_job(job)
+          add_to_active_queue JSON.generate(job)
+        end
+
+        def handle_prior_failures
+          # TODO consume the failed_queue and do something with it (loggly? retry? flat file?)
+        end
+
+        def count_active_queue
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

data/lib/keen/async/storage/redis_handler.rb

@@ -6,141 +6,79 @@ require 'time'
 module Keen
   module Async
     module Storage
-      class RedisHandler
+      class RedisHandler < Keen::Async::Storage::BaseStorageHandler
 
         # Keys
         # ----
 
-        def global_key_prefix
-          "keen"
-        end
-        
-        def active_queue_key
-          "#{global_key_prefix}.active_queue_key"
-        end
-
-        def failed_queue_key
-          "#{global_key_prefix}.failed_queue_key"
-        end
-
         def add_to_active_queue(value)
-          @redis.lpush active_queue_key, value
+          redis.lpush active_queue_key, value
           if @logging
-            puts "added #{value} to active queue; length is now #{@redis.llen active_queue_key}"
+            puts "added #{value} to active queue; length is now #{redis.llen active_queue_key}"
           end
         end
 
-        def record_job(job)
-          add_to_active_queue JSON.generate(job)
-        end
-
-        def handle_prior_failures
-          # TODO consume the failed_queue and do something with it (loggly? retry? flat file?)
+        def redis
+          unless @redis
+            @redis = Redis.new
+          end
+          
+          @redis
         end
 
-        def initialize(logging = false)
-          @redis = Redis.new
-          @logging = logging
-        end
-        
-        def redis=(connection)
-          @redis = connection
+        def count_active_queue
+          redis.llen active_queue_key
         end
 
-        def count_active_queue
-          @redis.llen active_queue_key
+        def clear_active_queue
+          redis.del active_queue_key
         end
 
-        def get_collated_jobs(how_many)
-
-          # Returns a hash of the next `how_many` jobs, indexed on project_id and then collection_name.
-          #
-          # It looks like this:
-          #
-          #  collated = {
-          #    "4f5775ad163d666a6100000e" => {
-          #      "clicks" => [
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "clicks",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "clicks",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "clicks",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #      ],
-          #      "purchases" => [
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "purchases",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "purchases",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #        Keen::Storage::Job.new({
-          #          :project_id => "4f5775ad163d666a6100000e",
-          #          :auth_token => "a5d4eaf432914823a94ecd7e0cb547b9",
-          #          :collection_name => "purchases",
-          #          :event_body => {:user_id => "12345"},
-          #        }),
-          #      ],
-          #    }
-          #  }
+        def get_authorized_jobs(how_many, client)
 
           handle_prior_failures
 
           key = active_queue_key
 
-          jobs = []
+          job_definitions = []
+          skipped_job_definitions = []
 
           #puts "doing the job #{how_many} times"
 
-          how_many.times do
-            this = @redis.lpop key
-            if this
-              jobs.push JSON.parse this
-            else
-              #puts "couldn't process value #{this}"
-            end
-          end
-
-          collate_jobs(jobs)
-        end
-
-        def collate_jobs(queue)
-          collated = {}
+          while true do
+            this = redis.lpop key
 
-          queue.each do |job_hash|
+            # If we're out of jobs, end the loop:
+            if not this
+              break
+            end
+            
+            # Parse the JSON into a job definition
+            job_definition = JSON.parse this
+            job_definition = Keen::Utils.symbolize_keys(job_definition)
+
+            # Make sure this client is authorized to process this job:
+            unless job_definition[:project_id] == client.project_id
+              unless job_definition[:auth_token] == client.auth_token
+                # We're not authorized, so skip this job.
+                skipped_job_definitions.push job_definition
+                next
+              end
+            end
 
-            job = Keen::Async::Job.new(self, job_hash)
+            job_definitions.push job_definition
 
-            if not collated.has_key? job.project_id
-              collated[job.project_id] = {}
+            if job_definitions.length == how_many
+              break
             end
 
-            if not collated[job.project_id].has_key? job.collection_name
-              collated[job.project_id][job.collection_name] = []
-            end
+          end
 
-            collated[job.project_id][job.collection_name].push(job)
+          # Put the skipped jobs back on the queue.
+          skipped_job_definitions.each do |job_definition|
+            redis.lpush key, job_definition
           end
 
-          collated
         end
 
       end

data/lib/keen/async/worker.rb

@@ -1,7 +1,4 @@
 require "keen/async/storage/redis_handler"
-require "net/http"
-require "net/https"
-
 
 
 module Keen
@@ -14,67 +11,46 @@ module Keen
      
     class Worker
 
-      def initialize(handler)
-        @handler = handler
+      def initialize(client)
+        @client = client
+        @storage_handler = client.storage_handler
       end
 
       def batch_url(project_id)
         if not project_id
           raise "Missing project_id."
         end
-        "https://api.keen.io/1.0/projects/#{project_id}/_events"
+        "https://api.keen.io/2.0/projects/#{project_id}/_events"
       end
 
       def process_queue
-
-        queue_length = @handler.count_active_queue
+        queue_length = @storage_handler.count_active_queue
 
         batch_size = Keen::Async::BATCH_SIZE
 
-        num_batches = 1 + queue_length / batch_size
 
+        events = []
+
+
+        responses = []
+
+        num_batches = queue_length / batch_size + 1
         num_batches.times do
-          collated = @handler.get_collated_jobs(batch_size)
-          collated.each do |project_id, batch|
-            send_batch(project_id, batch)
+
+          job_definitions = @storage_handler.get_authorized_jobs(batch_size, @client)
+
+          job_definitions.each do |job_definition|
+            #puts JSON.generate job_definition
+            job = Keen::Async::Job.new(@client, job_definition)
+            events.push Keen::Event.new(job.timestamp, job.collection_name, job.event_body)
           end
-        end
 
-        return "Worker sent #{num_batches} batches of #{batch_size} events per batch."
-      end
-      
-      def send_batch(project_id, batch)
-        if not batch
-          return
+          responses.push @client.send_batch(events)
         end
-        
-        first_key = batch.keys[0]
-        job_list = batch[first_key]
-        auth_token = job_list[0].auth_token
-        
-        uri = URI.parse(batch_url(project_id))
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.ca_file = Keen::Async::SSL_CA_FILE
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        http.verify_depth = 5
-
-        request = Net::HTTP::Post.new(uri.path)
-        request.body = batch.to_json
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = auth_token
-
-        response = http.request(request)
-
-        #response = Net::HTTP.start(uri.host, uri.port) {|http|
-          #http.request(request)
-        #}
-
-        puts response
-        # TODO: If something fails, we should move the job to the 
-        # prior_failures queue by calling, perhaps:
-        #
-        # @handler.log_failed_job(job)
+
+
+        responses
+
       end
 
     end

data/lib/keen/client.rb

@@ -1,15 +1,23 @@
-require "keen/async/storage/redis_handler"
-require "keen/async/job"
 require "json"
 require "uri"
 require "time"
+require "net/http"
+require "net/https"
 
 
 module Keen
 
   class Client
 
-    attr_accessor :storage_handler, :project_id, :auth_token
+    attr_accessor :storage_handler, :project_id, :auth_token, :options
+
+    def base_url
+      if @options[:base_url]
+        @options[:base_url]
+      else
+        "https://api.keen.io/2.0"
+      end
+    end
 
     def initialize(project_id, auth_token, options = {})
 
@@ -17,20 +25,39 @@ module Keen
       raise "auth_token must be string" unless auth_token.kind_of? String
 
       default_options = {
-        :storage_mode => :redis,
+        :logging => true,
+        
+        # warning! not caching locally leads to bad performance:
+        :cache_locally => true, 
+
+        # this is required if cache_locally is true:
+        :storage_class => nil, 
+
+        # all keys will be prepended with this:
+        :storage_namespace => "default",
       }
-      
+
       options = default_options.update(options)
 
       @project_id = project_id
       @auth_token = auth_token
-      @storage_mode = options[:storage_mode]
-    end
+      @cache_locally = options[:cache_locally]
 
-    def handler
+      if @cache_locally
+        @storage_class = options[:storage_class]
+        unless @storage_class and @storage_class < Keen::Async::Storage::BaseStorageHandler
+          raise "The Storage Class you send must extend BaseStorageHandler.  You sent: #{@storage_class}"
+        end
+      end
+
+      @logging = options[:logging]
+      @options = options
 
+    end
+
+    def storage_handler
       unless @storage_handler
-        @storage_handler = self.class.create_new_storage_handler(@storage_mode)
+        @storage_handler = @storage_class.new(self)
       end
 
       @storage_handler
@@ -44,33 +71,98 @@ module Keen
       #
       # `timestamp` is optional. If sent, it should be a Time instance.  
       #  If it's not sent, we'll use the current time.
-
+      
       validate_collection_name(collection_name)
 
       unless timestamp
         timestamp = Time.now
       end
 
-      event_body[:_timestamp] = timestamp.utc.iso8601
+      timestamp = timestamp.utc.iso8601
 
-      job = Keen::Async::Job.new(handler, {
-        :project_id => @project_id,
-        :auth_token => @auth_token,
-        :collection_name => collection_name,
-        :event_body => event_body,
-      })
+      event = Keen::Event.new(timestamp, collection_name, event_body)
+
+      if @cache_locally
+        job = Keen::Async::Job.new(storage_handler, {
+          :timestamp => event.timestamp,
+          :project_id => @project_id,
+          :auth_token => @auth_token,
+          :collection_name => collection_name,
+          :event_body => event.body,
+        })
+
+        job.save
+      else
+        # build the request:
+        url = "#{base_url}/projects/#{project_id}/#{collection_name}"
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.ca_file = Keen::Async::SSL_CA_FILE
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.verify_depth = 5
+
+        request = Net::HTTP::Post.new(uri.path)
+        request.body = JSON.generate({
+          :header => {
+            :timestamp => event.timestamp,
+          },
+          :body => event.body
+        })
+
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = @auth_token
+
+        response = http.request(request)
+        JSON.parse response.body
+      end
+    end
+
+    def send_batch(events)
+      # make the request body:
+      request_body = {}
+      events.each { |event| 
+        unless request_body.has_key? event.collection_name
+          request_body[event.collection_name] = []
+        end
+
+        header = {"timestamp" => event.timestamp}
+        body = event.body
+        item = {"header" => header, "body" => body}
+        request_body[event.collection_name].push(item)
+      }
+      request_body = request_body.to_json
+    
+      # build the request:
+      url = "#{base_url}/projects/#{project_id}/_events"
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.ca_file = Keen::Async::SSL_CA_FILE
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.verify_depth = 5
+
+      request = Net::HTTP::Post.new(uri.path)
+      request.body = request_body
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = auth_token
+
+      resp = http.request(request)
+
+      return JSON.parse resp.body
 
-      job.save
     end
 
     def validate_collection_name(collection_name)
       # TODO
     end
 
-    def self.create_new_storage_handler(storage_mode)
+    def self.create_new_storage_handler(storage_mode, client, logging)
+      # This is shitty as hell.  We shoudl take in a class reference pointing to the storage handler, not switch on string values
       case storage_mode.to_sym
+
       when :redis
-        Keen::Async::Storage::RedisHandler.new
+        Keen::Async::Storage::RedisHandler.new(client, logging)
       else
         raise "Unknown storage_mode sent to client: `#{storage_mode}`"
       end

data/lib/keen/event.rb

@@ -0,0 +1,13 @@
+module Keen
+  class Event
+
+    attr_accessor :timestamp, :collection_name, :body
+
+    def initialize(timestamp, collection_name, body)
+      @timestamp = timestamp
+      @collection_name = collection_name
+      @body = body
+    end
+
+  end
+end

data/lib/keen/keys.rb

@@ -0,0 +1,6 @@
+module Keen
+  TEST_PROJECT_ID = '4f5775ad163d666a6100000e'
+  TEST_AUTH_TOKEN = 'a5d4eaf432914823a94ecd7e0cb547b9'
+  #TEST_PROJECT_ID = 'abc'
+  #TEST_AUTH_TOKEN = '123'
+end

data/lib/keen/version.rb

@@ -1,3 +1,3 @@
 module Keen
-  VERSION = "0.0.53"
+  VERSION = "0.1.0"
 end

data/send.rb

@@ -0,0 +1,12 @@
+require "rubygems"
+require "keen"
+
+storage_handler = Keen::Client.create_new_storage_handler(:redis)
+
+count = storage_handler.count_active_queue
+puts "we have this many jobs: #{count}"
+
+worker = Keen::Async::Worker.new(storage_handler)
+results = worker.process_queue
+
+puts results

data/test/keen_spec.rb

@@ -1,44 +1,34 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
 
 require "keen"
-require "fakeweb"
 
 describe Keen::Client do
 
-  # Make it so that we don't actually hit keen server during tests:
-  before :all do
-    FakeWeb.register_uri(:any, %r/https:\/\/api.keen.io\//, :body => '{"message": "You tried to reach Keen"}')
-  end
-
+  # The add_event method should add stuff to Redis:
   describe "#add_event" do
+
+    # set up the Keen Client instance:
     project_id = "4f5775ad163d666a6100000e"
     auth_token = "a5d4eaf432914823a94ecd7e0cb547b9"
 
-    keen = Keen::Client.new(project_id, auth_token, :storage_mode => :redis)
+    # Make a client:
+    client = Keen::Client.new(project_id, 
+                              auth_token, 
+                              :storage_class => Keen::Async::Storage::RedisHandler,
+                              :logging => true )
 
-    310.times do
-      keen.add_event("rspec_clicks", {
+    # Flush the queue first:
+    client.clear_active_queue()
+
+    # Send some events to the client, which should persist them in Redis
+    5.times do
+      client.add_event("rspec_clicks", {
         :hi => "you",
       })
     end
 
-    worker = Keen::Async::Worker.new(handler = keen.storage_handler)
-
-    worker.process_queue
+    # Make sure we have the right number of things in the queue:
+    client.storage_handler.count_active_queue.should == 5
 
   end
-  
-  # TODO spec it out, lazy bones!
-  #
-  #
-  # Each time an event is logged, we'll store a json-serialized, base64-
-  # encoded, and gzipped hash that loos like this:
-  #
-  # {
-  #   :project_id       => "alsdjfaldskfjadskladsklj",
-  #   :auth_token       => "aslkjflk3wjfaklsjdflkasdjflkadjflakdj211",
-  #   :collection_name  => "purchases",
-  #   :event_body       => {:prop1 => "val1", :prop2 => "val2"},
-  # }
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: keen
 version: !ruby/object:Gem::Version 
-  hash: 117
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 53
-  version: 0.0.53
+  version: 0.1.0
 platform: ruby
 authors: 
 - Kyle Wild
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-11 00:00:00 -07:00
+date: 2012-06-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,35 +35,35 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: fakeweb
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 43
         segments: 
-        - 1
-        - 3
+        - 2
+        - 9
         - 0
-        version: 1.3.0
+        version: 2.9.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: cucumber
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 29
         segments: 
+        - 1
         - 2
-        - 9
-        - 0
-        version: 2.9.0
+        - 1
+        version: 1.2.1
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -82,22 +82,6 @@ dependencies:
         version: 1.2.4
   type: :runtime
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: redis
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 2
-        - 2
-        version: 2.2.2
-  type: :runtime
-  version_requirements: *id005
 description: See the github repo or examples.rb for usage information.
 email: 
 - kyle@keen.io
@@ -110,7 +94,6 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .rvmrc
-- Gemfile
 - README.md
 - bin/keen_send
 - conf/cacert.pem
@@ -189,15 +172,24 @@ files:
 - examples/rails_2/CoolForums/test/unit/helpers/users_helper_test.rb
 - examples/rails_2/CoolForums/test/unit/user_test.rb
 - examples/rails_2/Gemfile
+- features/add_event.feature
+- features/redis_queue.feature
+- features/step_definitions/keen_steps.rb
+- features/support/before_and_after.rb
 - keen.gemspec
 - lib/keen.rb
+- lib/keen/async.rb
 - lib/keen/async/job.rb
+- lib/keen/async/storage/base_storage_handler.rb
 - lib/keen/async/storage/flat_file_handler.rb
 - lib/keen/async/storage/redis_handler.rb
 - lib/keen/async/worker.rb
 - lib/keen/client.rb
+- lib/keen/event.rb
+- lib/keen/keys.rb
 - lib/keen/utils.rb
 - lib/keen/version.rb
+- send.rb
 - test/keen_spec.rb
 has_rdoc: true
 homepage: https://github.com/keenlabs/KeenClient-Ruby
@@ -234,4 +226,8 @@ signing_key:
 specification_version: 3
 summary: A library for sending events to the keen.io API.
 test_files: 
+- features/add_event.feature
+- features/redis_queue.feature
+- features/step_definitions/keen_steps.rb
+- features/support/before_and_after.rb
 - test/keen_spec.rb

data/Gemfile

@@ -1,3 +0,0 @@
-source :rubygems
-gem 'rspec'
-gem 'fakeweb'