keen 0.6.0 → 0.6.1

data/README.md

@@ -29,13 +29,15 @@ Before making any API calls, you must supply keen-gem with a Project ID.
 The recommended way to do this is to set `KEEN_PROJECT_ID` in your
 environment. If you're using [foreman](http://ddollar.github.com/foreman/), add this to your `.env` file:
 
-    KEEN_PROJECT_ID=your-project-id
+    KEEN_PROJECT_ID=xxxxxxxxxxxxxxxx
 
-When you deploy, make sure your production environment variables are also set. For example,
+If not, make to to export the variable into your shell or put it before the command you use to start your server.
+
+When you deploy, make sure your production environment variables are set. For example,
 set [config vars](https://devcenter.heroku.com/articles/config-vars) on Heroku. (We recommend this
 environment-based approach because it keeps sensitive information out of the codebase. If you can't do this, see the alternatives below.)
 
-If your environment is set up property, `Keen` is ready go immediately. Publish an event like this:
+If your environment is set up property, `Keen` is ready to go immediately. Publish an event like this:
 
 ```ruby
 Keen.publish("sign_ups", { :username => "lloyd", :referred_by => "harry" })
@@ -60,7 +62,11 @@ method to send events.
 To compare asychronous vs. synchronous performance, check out the [keen-gem-example](http://keen-gem-example.herokuapp.com/) app.
 
 To publish asynchronously, first add
-[em-http-request](https://github.com/igrigorik/em-http-request) to your Gemfile.
+[em-http-request](https://github.com/igrigorik/em-http-request) to your Gemfile. Make sure it's version 1.0 or above.
+
+```ruby
+gem "em-http-request", "~> 1.0"
+```
 
 Next, run an instance of EventMachine. If you're using an EventMachine-based web server like
 thin or goliath you're already doing this. Otherwise, you'll need to start an EventMachine loop manually as follows:
@@ -93,7 +99,7 @@ Unlike event publishing, queries require that an API Key is provided. Just like
 
     KEEN_API_KEY=your-api-key
 
-Here's are some examples of querying with the Ruby gem. Let's assume you've added some events to the "purchases" collection.
+Here's are some examples of querying with keen-gem. Let's assume you've added some events to the "purchases" collection.
 
 ```ruby
 Keen.count("purchases") # => 100
@@ -110,9 +116,14 @@ Keen.select_unique("purchases", :target_property => "username")  # => ["bob", "l
 Keen.extraction("purchases")  # => [{ "price" => 20, ... }, { ... }]
 
 Keen.funnel(:steps => [
-  { :actor_property => "username", "event_collection" => "purchases" },
-  { :actor_property => "username", "event_collection" => "referrals" },
+  { :actor_property => "username", :event_collection => "purchases" },
+  { :actor_property => "username", :event_collection => "referrals" },
   { ... }])  # => [20, 15 ...]
+
+Keen.multi_analysis("purchases", analyses: {
+  :gross =>      { :analysis_type => "sum", :target_property => "price" },
+  :customers =>  { :analysis_type => "count_unique", :target_property => "username" } },
+  :timeframe => 'today', :group_by => "item.id") # => [{"item.id"=>2, "gross"=>314.49, "customers"=> 8}, { ... }]
 ```
 
 Many of there queries can be performed with group by, filters, series and intervals. The API response for these is converted directly into Ruby Hash or Array.
@@ -159,6 +170,9 @@ To track email opens, simply add an image to your email template that points to
 
 ### Changelog
 
+##### 0.6.1
++ Improved logging and exception handling.
+
 ##### 0.6.0
 + Added querying capabilities. A big thanks to [ifeelgoods](http://www.ifeelgoods.com/) for contributing!
 
@@ -185,3 +199,10 @@ at [users.keen.io](http://users.keen.io). We'd love to hear your feedback and id
 ### Contributing
 keen-gem is an open source project and we welcome your contributions.
 Fire away with issues and pull requests!
+
+### Community Contributors
++ [alexkwolfe](https://github.com/alexkwolfe)
++ [peteygao](https://github.com/peteygao)
++ [obieq](https://github.com/obieq)
+ 
+Thanks everyone, you rock!

data/lib/keen/client/publishing_methods.rb

@@ -32,7 +32,7 @@ module Keen
               :headers => api_headers("sync"),
               :body => MultiJson.encode(properties))
         rescue Exception => http_error
-          raise HttpError.new("Couldn't connect to Keen IO: #{http_error.message}", http_error)
+          raise HttpError.new("HTTP publish failure: #{http_error.message}", http_error)
         end
         process_response(response.code, response.body.chomp)
       end
@@ -60,8 +60,9 @@ module Keen
 
         if defined?(EM::Synchrony)
           if http.error
-            Keen.logger.warn("Couldn't connect to Keen IO: #{http.error}")
-            raise HttpError.new("Couldn't connect to Keen IO: #{http.error}")
+            error = HttpError.new("HTTP em-synchrony publish_async error: #{http.error}")
+            Keen.logger.error(error)
+            raise error
           else
             process_response(http.response_header.status, http.response.chomp)
           end
@@ -69,14 +70,16 @@ module Keen
           http.callback {
             begin
               response = process_response(http.response_header.status, http.response.chomp)
-              deferrable.succeed(response)
             rescue Exception => e
+              Keen.logger.error(e)
               deferrable.fail(e)
             end
+            deferrable.succeed(response) if response
           }
           http.errback {
-            Keen.logger.warn("Couldn't connect to Keen IO: #{http.error}")
-            deferrable.fail(Error.new("Couldn't connect to Keen IO: #{http.error}"))
+            error = Error.new("HTTP publish_async failure: #{http.error}")
+            Keen.logger.error(error)
+            deferrable.fail(error)
           }
           deferrable
         end

data/lib/keen/client/querying_methods.rb

@@ -1,3 +1,4 @@
+
 module Keen
   class Client
     module QueryingMethods
@@ -141,6 +142,23 @@ module Keen
         query(__method__, nil, params)
       end
 
+      # Runs a multi-analysis query
+      # See detailed documentation here:
+      # https://keen.io/docs/data-analysis/multi-analysis/
+      #
+      # NOTE: why isn't multi-analysis listed in the
+      #       API Technical Reference?
+      #
+      # @param event_collection
+      # @param params [Hash]
+      #   analyses [Hash] (required)
+      #     label (required)
+      #     analysis_type (required)
+      #     target_property (optional)
+      def multi_analysis(event_collection, params)
+        query(__method__, event_collection, params)
+      end
+
       private
 
       def query(query_name, event_collection, params)
@@ -177,6 +195,10 @@ module Keen
           params[:steps] = MultiJson.encode(params[:steps])
         end
 
+        if params.key?(:analyses)
+          params[:analyses] = MultiJson.encode(params[:analyses])
+        end
+
         if params.key?(:timeframe) && params[:timeframe].is_a?(Hash)
           params[:timeframe] = MultiJson.encode(params[:timeframe])
         end
@@ -196,4 +218,3 @@ module Keen
     end
   end
 end
-

data/lib/keen/client.rb

@@ -53,18 +53,22 @@ module Keen
     private
 
     def process_response(status_code, response_body)
-      body = MultiJson.decode(response_body)
       case status_code.to_i
       when 200..201
-        return body
+        begin
+          return MultiJson.decode(response_body)
+        rescue
+          Keen.logger.warn("Invalid JSON for response code #{status_code}: #{response_body}")
+          return {}
+        end
       when 400
-        raise BadRequestError.new(body)
+        raise BadRequestError.new(response_body)
       when 401
-        raise AuthenticationError.new(body)
+        raise AuthenticationError.new(response_body)
       when 404
-        raise NotFoundError.new(body)
+        raise NotFoundError.new(response_body)
       else
-        raise HttpError.new(body)
+        raise HttpError.new(response_body)
       end
     end
 

data/lib/keen/version.rb

@@ -1,3 +1,3 @@
 module Keen
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

data/lib/keen.rb

@@ -10,6 +10,10 @@ module Keen
       self.original_error = _original_error
       super(message)
     end
+
+    def to_s
+      "Keen IO Exception: #{super}"
+    end
   end
 
   class ConfigurationError < Error; end

data/spec/integration/api_spec.rb

@@ -70,7 +70,7 @@ describe "Keen IO API" do
         :username => "bob",
         :price => 30
       })
-      sleep(1)
+      sleep(5)
     end
 
     it "should return a valid count" do

data/spec/keen/client/publishing_methods_spec.rb

@@ -50,7 +50,7 @@ describe Keen::Client::PublishingMethods do
 
       e.class.should == Keen::HttpError
       e.original_error.class.should == Timeout::Error
-      e.message.should == "Couldn't connect to Keen IO: execution expired"
+      e.message.should == "Keen IO Exception: HTTP publish failure: execution expired"
     end
 
     it "should raise an exception if client has no project_id" do
@@ -87,7 +87,7 @@ describe Keen::Client::PublishingMethods do
         EM.run {
           client.publish_async("foo bar", event_properties).callback {
             begin
-              expect_post(api_event_resource_url("foo%20bar"), event_properties, "async")
+              expect_keen_post(api_event_resource_url("foo%20bar"), event_properties, "async")
             ensure
               EM.stop
             end
@@ -127,13 +127,28 @@ describe Keen::Client::PublishingMethods do
             client.publish_async(collection, event_properties).errback { |error|
               begin
                 error.should_not be_nil
-                error.message.should == "Couldn't connect to Keen IO: WebMock timeout error"
+                error.message.should == "Keen IO Exception: HTTP publish_async failure: WebMock timeout error"
               ensure
                 EM.stop
               end
             }
           }
         end
+
+        it "should not trap exceptions in the client callback" do
+          stub_keen_post(api_event_resource_url("foo%20bar"), 201, api_success)
+          expect {
+            EM.run {
+              client.publish_async("foo bar", event_properties).callback {
+                begin
+                  blowup
+                ensure
+                  EM.stop
+                end
+              }
+            }
+          }.to raise_error
+        end
       end
     end
   end

data/spec/keen/client/querying_methods_spec.rb

@@ -15,7 +15,7 @@ describe Keen::Client do
   describe "querying names" do
     let(:params) { { :event_collection => "signups" } }
 
-    ["minimum", "maximum", "sum", "average", "count", "count_unique", "select_unique", "extraction"].each do |query_name|
+    ["minimum", "maximum", "sum", "average", "count", "count_unique", "select_unique", "extraction", "multi_analysis"].each do |query_name|
       it "should call keen query passing the query name" do
         client.should_receive(:query).with(query_name.to_sym, event_collection, params)
         client.send(query_name, event_collection, params)

data/spec/keen/client_spec.rb

@@ -25,34 +25,43 @@ describe Keen::Client do
 
   describe "process_response" do
     let (:body) { "{ \"wazzup\": 1 }" }
+    let (:exception_body) { "Keen IO Exception: { \"wazzup\": 1 }" }
     let (:process_response) { client.method(:process_response) }
 
-    it "should raise a bad request error for a 400" do
+    it "should return encoded json for a 200" do
       process_response.call(200, body).should == { "wazzup" => 1 }
     end
 
+    it "should return encoded json for a 201" do
+      process_response.call(201, body).should == { "wazzup" => 1 }
+    end
+
+    it "should return empty for bad json on a 200/201" do
+      process_response.call(200, "invalid json").should == {}
+    end
+
     it "should raise a bad request error for a 400" do
       expect {
         process_response.call(400, body)
-      }.to raise_error(Keen::BadRequestError)
+      }.to raise_error(Keen::BadRequestError, exception_body)
     end
 
     it "should raise a authentication error for a 401" do
       expect {
         process_response.call(401, body)
-      }.to raise_error(Keen::AuthenticationError)
+      }.to raise_error(Keen::AuthenticationError, exception_body)
     end
 
     it "should raise a not found error for a 404" do
       expect {
         process_response.call(404, body)
-      }.to raise_error(Keen::NotFoundError)
+      }.to raise_error(Keen::NotFoundError, exception_body)
     end
 
     it "should raise an http error otherwise" do
       expect {
         process_response.call(420, body)
-      }.to raise_error(Keen::HttpError)
+      }.to raise_error(Keen::HttpError, exception_body)
     end
   end
 end

data/spec/synchrony/synchrony_spec.rb

@@ -41,7 +41,7 @@ describe Keen::HTTP::Async do
             e = exception
           end
           e.class.should == Keen::HttpError
-          e.message.should == "Couldn't connect to Keen IO: WebMock timeout error"
+          e.message.should == "Keen IO Exception: HTTP em-synchrony publish_async error: WebMock timeout error"
           EM.stop
         }
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keen
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json