appstats 0.14.0 → 0.15.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    appstats (0.14.0)
+    appstats (0.15.0)
       daemons
       net-scp
       rails (>= 2.3.0)

data/db/migrations/20110301195959_add_appstats_results_groups.rb

@@ -0,0 +1,9 @@
+class AddAppstatsResultsGroups < ActiveRecord::Migration
+  def self.up
+    add_column :appstats_results, :group_by, :string
+  end
+
+  def self.down
+    remove_column :appstats_results, :group_by
+  end
+end

data/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20110301170947) do
+ActiveRecord::Schema.define(:version => 20110301195959) do
 
   create_table "appstats_actions", :force => true do |t|
     t.string   "name"
@@ -119,6 +119,7 @@ ActiveRecord::Schema.define(:version => 20110301170947) do
     t.datetime "updated_at"
     t.text     "contexts"
     t.text     "group_query_to_sql"
+    t.string   "group_by"
   end
 
   add_index "appstats_results", ["action"], :name => "index_appstats_results_on_action"

data/lib/appstats/query.rb

@@ -2,13 +2,13 @@
 module Appstats
   class Query
 
-    @@parser_template = Appstats::Parser.new(:rules => ":operation :action :date on :host where :contexts group by :groups")
+    @@parser_template = Appstats::Parser.new(:rules => ":operation :action :date on :host where :contexts group by :group_by")
     @@contexts_parser_template = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> != ( ) like")
-    @@groups_parser_template = Appstats::Parser.new(:rules => ":filter", :repeating => true, :tokenize => ",")
+    @@group_by_parser_template = Appstats::Parser.new(:rules => ":filter", :repeating => true, :tokenize => ",")
 
     @@nill_query = "select 0 from appstats_entries LIMIT 1"
     @@default = "1=1"
-    attr_accessor :name, :query, :action, :host, :date_range, :query_to_sql, :contexts, :groups, :group_query_to_sql
+    attr_accessor :name, :query, :action, :host, :date_range, :query_to_sql, :contexts, :group_by, :group_query_to_sql
 
     def initialize(data = {})
       @name = data[:name]
@@ -23,14 +23,18 @@ module Appstats
     
     def run
       result = Appstats::Result.new(:name => @name, :result_type => @result_type, :query => @query, :query_as_sql => @query_to_sql, :action => @action, :host => @host, :from_date => @date_range.from_date, :to_date => @date_range.to_date, :contexts => @contexts)
+      result.group_by = @group_by.join(", ") unless @group_by.empty?
       result.count = ActiveRecord::Base.connection.select_one(@query_to_sql)["count(*)"].to_i
       result.save
       
-      unless @groups.empty?
+      unless @group_by.empty?
         all_sub_results = ActiveRecord::Base.connection.select_all(@group_query_to_sql)
         all_sub_results.each do |data|
+          keys = data["context_key_filter"].split(",")
+          values = data["context_value_filter"].split(",")
+          key_values = {} and keys.each_with_index { |k,i| key_values[k] = values[i] }
           ratio_of_total = data["num"].to_f / result.count
-          sub_result = Appstats::SubResult.new(:context_filter => data["context_filter"], :count => data["num"], :ratio_of_total => ratio_of_total)
+          sub_result = Appstats::SubResult.new(:context_filter => @group_by.collect { |k| key_values[k] }.join(", "), :count => data["num"], :ratio_of_total => ratio_of_total)
           sub_result.result = result
           sub_result.save
         end
@@ -113,12 +117,12 @@ module Appstats
         action.nil? ? action_name : action.name 
       end
       
-      def parse_groups(raw_input)
-        group_parser = @@groups_parser_template.dup
+      def parse_group_by(raw_input)
+        group_parser = @@group_by_parser_template.dup
         return if (raw_input.blank? || !group_parser.parse(raw_input))
         group_parser.raw_results.each do |entry|
           next if entry.kind_of?(String)
-          @groups<< entry[:filter]
+          @group_by<< entry[:filter]
         end
       end
       
@@ -135,7 +139,7 @@ module Appstats
         @date_range = DateRange.parse(parser.results[:date])
         @host = parser.results[:host]
         @contexts = parser.results[:contexts]
-        parse_groups(parser.results[:groups])
+        parse_group_by(parser.results[:group_by])
         
         if @operation == "#"
           @query_to_sql = "select count(*) from appstats_entries"
@@ -145,10 +149,10 @@ module Appstats
           @query_to_sql += " and #{Query.contexts_filter_to_sql(@contexts)}" unless @contexts.nil?
         end
 
-        unless @groups.empty?
+        unless @group_by.empty?
           query_to_sql_with_id = @query_to_sql.sub("count(*)","id")
-          group_as_sql = @groups.collect { |g| "'#{Query.sqlclean(g)}'" }.join(',')
-          @group_query_to_sql = "select context_filter, count(*) num from (select group_concat(appstats_contexts.context_value separator ', ') as context_filter, appstats_entry_id from appstats_contexts where context_key in (#{group_as_sql}) and appstats_entry_id in ( #{query_to_sql_with_id} ) group by appstats_entry_id) results group by context_filter;"
+          group_as_sql = @group_by.collect { |g| "'#{Query.sqlclean(g)}'" }.join(',')
+          @group_query_to_sql = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in (#{group_as_sql}) and appstats_entry_id in ( #{query_to_sql_with_id} ) group by appstats_entry_id) results group by context_value_filter;"
         end
 
         @query_to_sql
@@ -174,7 +178,7 @@ module Appstats
         @host = nil
         nil_query
         @date_range = DateRange.new
-        @groups = []
+        @group_by = []
       end
     
   end

data/lib/appstats/result.rb

@@ -2,7 +2,7 @@ module Appstats
   class Result < ActiveRecord::Base
     set_table_name "appstats_results"
 
-    attr_accessible :name, :result_type, :query, :query_as_sql, :count, :action, :host, :from_date, :to_date, :contexts
+    attr_accessible :name, :result_type, :query, :query_as_sql, :count, :action, :host, :from_date, :to_date, :contexts, :group_by
     has_many :sub_results, :table_name => 'appstats_subresults', :foreign_key => 'appstats_result_id', :order => 'count DESC'
 
     def date_to_s
@@ -47,7 +47,7 @@ module Appstats
     private
 
       def state
-        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date,contexts]
+        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date,contexts,group_by]
       end
 
     

data/lib/appstats/version.rb

@@ -1,3 +1,3 @@
 module Appstats
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 end

data/spec/entry_spec.rb

@@ -193,18 +193,18 @@ module Appstats
       end
       
       it "should understand an entry without contexts" do
-        entry = Entry.create_from_logger_string("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+        entry = Entry.create_from_logger_string("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_search"
-        entry.raw_entry.should == "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        entry.raw_entry.should == "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
       end
       
       it "should understand contexts" do
-        entry = Entry.create_from_logger_string("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+        entry = Entry.create_from_logger_string("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_filter"
-        entry.raw_entry.should == "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        entry.raw_entry.should == "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "app_name"
@@ -214,10 +214,10 @@ module Appstats
       end
       
       it "should handle 'action' as a context" do
-        entry = Entry.create_from_logger_string('0.14.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb')
+        entry = Entry.create_from_logger_string('0.15.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb')
         Entry.count.should == @before_count + 1
         entry.action.should == "page-view"
-        entry.raw_entry.should == "0.14.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb"
+        entry.raw_entry.should == "0.15.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb"
         entry.occurred_at.should == Time.parse("2011-02-24 12:59:57")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "action"
@@ -228,10 +228,10 @@ module Appstats
       end
       
       it "should handle multiple of the same 'context'" do
-        entry = Entry.create_from_logger_string('0.14.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb')
+        entry = Entry.create_from_logger_string('0.15.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb')
         Entry.count.should == @before_count + 1
         entry.action.should == "page-view"
-        entry.raw_entry.should == "0.14.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb"
+        entry.raw_entry.should == "0.15.0 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb"
         entry.occurred_at.should == Time.parse("2011-02-24 12:59:57")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "app_name"

data/spec/logger_spec.rb

@@ -115,12 +115,12 @@ module Appstats
       
       it "should accept numbers" do
         Appstats::Logger.entry(5, :blah => 6)   
-        Appstats::Logger.raw_read.should == ["0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
+        Appstats::Logger.raw_read.should == ["0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
       end
 
       it "should accept arrays" do
         Appstats::Logger.entry('search', :provider => [ 'one', 'two' ])   
-        Appstats::Logger.raw_read.should == ["0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=search : provider=one : provider=two"]
+        Appstats::Logger.raw_read.should == ["0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=search : provider=one : provider=two"]
       end
 
 
@@ -130,7 +130,7 @@ module Appstats
 
       it "should look similar to regular entry" do
         Appstats::Logger.exception_entry(RuntimeError.new("blah"),:on => "login")   
-        Appstats::Logger.raw_read.should == ["0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
+        Appstats::Logger.raw_read.should == ["0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
       end
       
     end
@@ -147,47 +147,47 @@ module Appstats
     
        it "should handle a statistics entry" do
          expected = { :action => "address_search", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
          actual.should == expected
        end
        
        it "should handle contexts" do
          expected = { :action => "address_filter", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle multiple actions" do
          expected = { :action => ["address_filter", "blah"], :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : action=blah : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : action=blah : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle multiple of same context" do
          expected = { :action => "address_filter", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => ['Sin','Market'] }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Sin : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Sin : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle no actions" do
          expected = { :action => "UNKNOWN_ACTION", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 app_name=Market : server=Live")
          actual.should == expected
        end
     
        it "should handle actions with the delimiter (and change the delimiter)" do
          expected = { :action => "address:=search-n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
          actual.should == expected
     
          expected = { :action => "address::search==--n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
          actual.should == expected
        end
     
        it "should handle contexts with the delimiter (and change the delimiter)" do
          expected = { :action => "address", :timestamp => "2010-09-21 23:15:20", :server => "market:eval=-n" }
-         actual = Appstats::Logger.entry_to_hash("0.14.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
+         actual = Appstats::Logger.entry_to_hash("0.15.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
          actual.should == expected
        end
        
@@ -196,66 +196,66 @@ module Appstats
     describe "#entry_to_s" do
       
       it "should handle a statistics entry" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle numbers" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
         actual = Appstats::Logger.entry_to_s(1,:note => 2.2)
         actual.should == expected
       end
       
       it "should handle default contexts" do
         Appstats::Logger.default_contexts[:app_name] = "market"
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle contexts (and sort them by symbol)" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         actual = Appstats::Logger.entry_to_s("address_filter", { :server => "Live", :app_name => 'Market' })
         actual.should == expected
       end
 
       it "should handle actions with the delimiter (and change the delimiter)" do
-        expected = "0.14.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
+        expected = "0.15.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
         actual = Appstats::Logger.entry_to_s("address:=search-n")
         actual.should == expected
 
-        expected = "0.14.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
+        expected = "0.15.0 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
         actual = Appstats::Logger.entry_to_s("address::search==--n")
         actual.should == expected
       end
 
       it "should handle contexts with the delimiter (and change the delimiter)" do
-        expected = "0.14.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
+        expected = "0.15.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
         actual = Appstats::Logger.entry_to_s("address", :server => 'market:eval=-n')
         actual.should == expected
       end
 
       it "should ignore spaces" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
         actual = Appstats::Logger.entry_to_s("address search")
         actual.should == expected
       end
       
       it "should convert newlines in action" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
         actual = Appstats::Logger.entry_to_s("address_\nsearch")
         actual.should == expected
       end
 
       it "should convert newlines in context" do
-        expected = "0.14.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
+        expected = "0.15.0 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
         actual = Appstats::Logger.entry_to_s("address_search",:blah => "some\nlong\nstatement")
         actual.should == expected
       end
       
       it "should convert newlines based on the delimiter" do
-        expected = "0.14.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
+        expected = "0.15.0 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
         actual = Appstats::Logger.entry_to_s("address:=\nsearch-n")
         actual.should == expected
       end

data/spec/query_spec.rb

@@ -32,7 +32,7 @@ module Appstats
         query.action.should == nil
         query.host.should == nil
         query.date_range.should == DateRange.new
-        query.groups.should == []
+        query.group_by.should == []
         query.group_query_to_sql.should == nil
       end
     
@@ -41,7 +41,7 @@ module Appstats
         query.action.should == "myblahs"
         query.host.should == "xyz.localnet"
         query.date_range.should == DateRange.parse("today")
-        query.groups.should == []
+        query.group_by.should == []
         query.group_query_to_sql.should == nil
       end
     
@@ -50,7 +50,7 @@ module Appstats
         query.action.should == "myblahs"
         query.host.should == "xyz.localnet"
         query.date_range.should == DateRange.new
-        query.groups.should == []
+        query.group_by.should == []
         query.group_query_to_sql.should == nil
       end
     
@@ -59,7 +59,7 @@ module Appstats
         query.action.should == "myblahs"
         query.host.should == "xyz.localnet"
         query.date_range.should == DateRange.new
-        query.groups.should == []
+        query.group_by.should == []
         query.group_query_to_sql.should == nil
       end
 
@@ -67,12 +67,12 @@ module Appstats
 
         it "should handle single entry" do
           query = Appstats::Query.new(:query => "# myblahs group by aa")
-          query.groups.should == ["aa"]
+          query.group_by.should == ["aa"]
         end
 
         it "should handle multi-entry" do
           query = Appstats::Query.new(:query => "# myblahs group by aa,bbbb")
-          query.groups.should == ["aa","bbbb"]
+          query.group_by.should == ["aa","bbbb"]
         end
         
       end
@@ -91,14 +91,14 @@ module Appstats
           query = Appstats::Query.new(:query => "# blahs")
           result = query.run
           result.new_record?.should == false
-          result.should == Appstats::Result.new(:result_type => "on_demand", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs")
+          result.should == Appstats::Result.new(:result_type => "on_demand", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
         end
 
         it "should set name and result_type if provided" do
           query = Appstats::Query.new(:name => "x", :result_type => "some_reason", :query => "# blahs")
           result = query.run
           result.new_record?.should == false
-          result.should == Appstats::Result.new(:name => "x", :result_type => "some_reason", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs")
+          result.should == Appstats::Result.new(:name => "x", :result_type => "some_reason", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
         end
 
         it "should track contexts" do
@@ -185,13 +185,13 @@ module Appstats
       
       describe "group sub results" do
         
-        it "should not create sub results if no groups" do
+        it "should not create sub results if no group_by" do
           query = Appstats::Query.new(:query => "# myblahs last day")
           result = query.run
           result.sub_results.should == []
         end
 
-        it "should track sub results as required" do
+        it "should track sub results for single group by" do
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :ignore => "1")
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :ignore => "1")
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :ignore => "2")
@@ -200,14 +200,29 @@ module Appstats
           query = Appstats::Query.new(:query => "# myblahs group by service_provider")
           result = query.run
           result.count.should == 4
+          result.group_by.should == "service_provider"
           result.sub_results.size.should == 2
           
           result.sub_results[0].should == SubResult.new(:context_filter => "a", :count => 3, :ratio_of_total => 0.75)
           result.sub_results[1].should == SubResult.new(:context_filter => "b", :count => 1, :ratio_of_total => 0.25)
-
-
         end
         
+        it "should track sub results for multiple group by" do
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "2")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "b", :user => "1")
+          
+          query = Appstats::Query.new(:query => "# myblahs group by service_provider,user")
+          result = query.run
+          result.count.should == 4
+          result.group_by.should == "service_provider, user"
+          result.sub_results.size.should == 3
+          
+          result.sub_results[0].should == SubResult.new(:context_filter => "a, 1", :count => 2, :ratio_of_total => 0.50)
+          result.sub_results[1].should == SubResult.new(:context_filter => "b, 1", :count => 1, :ratio_of_total => 0.25)
+          result.sub_results[2].should == SubResult.new(:context_filter => "a, 2", :count => 1, :ratio_of_total => 0.25)
+        end        
         
       end
 
@@ -315,26 +330,26 @@ module Appstats
             
       it "should support 1 filter" do
         query = Appstats::Query.new(:query => "# myblahs group by aa")
-        expected = "select context_filter, count(*) num from (select group_concat(appstats_contexts.context_value separator ', ') as context_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
         query.group_query_to_sql.should == expected
       end
 
       it "should support surrounding quotes" do
         query = Appstats::Query.new(:query => "# myblahs group by 'aa'")
-        expected = "select context_filter, count(*) num from (select group_concat(appstats_contexts.context_value separator ', ') as context_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
         query.group_query_to_sql.should == expected
       end
 
       it "should support inner quotes" do
         query = Appstats::Query.new(:query => "# myblahs group by a's")
-        expected = "select context_filter, count(*) num from (select group_concat(appstats_contexts.context_value separator ', ') as context_filter, appstats_entry_id from appstats_contexts where context_key in ('a''s') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('a''s') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
         query.group_query_to_sql.should == expected
       end
 
 
       it "should support many filters" do
         query = Appstats::Query.new(:query => "# myblahs group by aa, bbb")
-        expected = "select context_filter, count(*) num from (select group_concat(appstats_contexts.context_value separator ', ') as context_filter, appstats_entry_id from appstats_contexts where context_key in ('aa','bbb') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa','bbb') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
         query.group_query_to_sql.should == expected
       end
       

data/spec/result_spec.rb

@@ -20,10 +20,11 @@ module Appstats
         @result.contexts.should == nil
         @result.from_date.should == nil
         @result.to_date.should == nil
+        @result.group_by.should == nil
       end
     
       it "should set on constructor" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
         result.name.should == 'a'
         result.result_type.should == 'b'
         result.query.should == 'c'
@@ -34,6 +35,7 @@ module Appstats
         result.contexts.should == 'g'
         result.from_date_to_s.should == '2010-01-02'
         result.to_date_to_s.should == '2010-02-03'
+        result.group_by.should == "a,b"
       end
     
     end
@@ -41,16 +43,16 @@ module Appstats
     describe "#==" do
       
       it "should be equal on all attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
-        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
+        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
         (result == same_result).should == true
       end
       
       it "should be not equal if diferent attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
         
-        [:name,:result_type,:query,:query_as_sql,:count,:action,:host,:contexts,:from_date,:to_date].each do |attr|
-          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"))  
+        [:name,:result_type,:query,:query_as_sql,:count,:action,:host,:contexts,:from_date,:to_date,:group_by].each do |attr|
+          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")  
 
           if [:from_date,:to_date].include?(attr)
             different_result.send("#{attr}=",Time.parse("2011-01-02"))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: appstats
 version: !ruby/object:Gem::Version 
-  hash: 39
+  hash: 35
   prerelease: false
   segments: 
   - 0
-  - 14
+  - 15
   - 0
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors: 
 - Andrew Forward
@@ -161,6 +161,7 @@ files:
 - db/migrations/20110225192624_add_appstats_log_collector_local_filename.rb
 - db/migrations/20110301170733_add_appstats_results_group_query_to_sql.rb
 - db/migrations/20110301170947_create_appstats_sub_results.rb
+- db/migrations/20110301195959_add_appstats_results_groups.rb
 - db/schema.rb
 - lib/appstats.rb
 - lib/appstats/action.rb