right_support 2.7.0 → 2.8.0

data/spec/stats/activity_spec.rb

@@ -43,151 +43,263 @@ describe RightSupport::Stats::Activity do
     @stats = RightSupport::Stats::Activity.new
   end
 
-  it "initializes stats data" do
-    @stats.instance_variable_get(:@interval).should == 0.0
-    @stats.instance_variable_get(:@last_start_time).should == @now
-    @stats.instance_variable_get(:@avg_duration).should be_nil
-    @stats.instance_variable_get(:@total).should == 0
-    @stats.instance_variable_get(:@count_per_type).should == {}
+  context :initialize do
+    it "initializes stats data" do
+      @stats.instance_variable_get(:@interval).should == 0.0
+      @stats.instance_variable_get(:@last_start_time).should == @now
+      @stats.instance_variable_get(:@avg_duration).should be_nil
+      @stats.instance_variable_get(:@total).should == 0
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
   end
 
-  it "updates count and interval information" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update
-    @stats.instance_variable_get(:@interval).should == 1.0
-    @stats.instance_variable_get(:@last_start_time).should == @now + 10
-    @stats.instance_variable_get(:@avg_duration).should be_nil
-    @stats.instance_variable_get(:@total).should == 1
-    @stats.instance_variable_get(:@count_per_type).should == {}
-  end
+  context :update do
+    it "updates count and interval information" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update
+      @stats.instance_variable_get(:@interval).should == 1.0
+      @stats.instance_variable_get(:@last_start_time).should == @now + 10
+      @stats.instance_variable_get(:@avg_duration).should be_nil
+      @stats.instance_variable_get(:@total).should == 1
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
 
-  it "updates weight the average interval toward recent activity" do
-  end
+    it "updates counts per type when type provided" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update("test")
+      @stats.instance_variable_get(:@interval).should == 1.0
+      @stats.instance_variable_get(:@last_start_time).should == @now + 10
+      @stats.instance_variable_get(:@avg_duration).should be_nil
+      @stats.instance_variable_get(:@total).should == 1
+      @stats.instance_variable_get(:@count_per_type).should == {"test" => 1}
+    end
 
-  it "updates counts per type when type provided" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update("test")
-    @stats.instance_variable_get(:@interval).should == 1.0
-    @stats.instance_variable_get(:@last_start_time).should == @now + 10
-    @stats.instance_variable_get(:@avg_duration).should be_nil
-    @stats.instance_variable_get(:@total).should == 1
-    @stats.instance_variable_get(:@count_per_type).should == {"test" => 1}
-  end
+    it "doesn't update counts when type contains 'stats'" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update("my stats")
+      @stats.instance_variable_get(:@interval).should == 0.0
+      @stats.instance_variable_get(:@last_start_time).should == @now
+      @stats.instance_variable_get(:@avg_duration).should be_nil
+      @stats.instance_variable_get(:@total).should == 0
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
 
-  it "doesn't update counts when type contains 'stats'" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update("my stats")
-    @stats.instance_variable_get(:@interval).should == 0.0
-    @stats.instance_variable_get(:@last_start_time).should == @now
-    @stats.instance_variable_get(:@avg_duration).should be_nil
-    @stats.instance_variable_get(:@total).should == 0
-    @stats.instance_variable_get(:@count_per_type).should == {}
-  end
+    it "limits length of type string when submitting update" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update("test 12345678901234567890123456789012345678901234567890123456789")
+      @stats.instance_variable_get(:@total).should == 1
+      @stats.instance_variable_get(:@count_per_type).should ==
+              {"test 1234567890123456789012345678901234567890123456789012..." => 1}
+    end
 
-  it "limits length of type string when submitting update" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update("test 12345678901234567890123456789012345678901234567890123456789")
-    @stats.instance_variable_get(:@total).should == 1
-    @stats.instance_variable_get(:@count_per_type).should ==
-            {"test 1234567890123456789012345678901234567890123456789012..." => 1}
-  end
+    it "doesn't convert symbol or boolean to string when submitting update" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update(:test)
+      @stats.update(true)
+      @stats.update(false)
+      @stats.instance_variable_get(:@total).should == 3
+      @stats.instance_variable_get(:@count_per_type).should == {:test => 1, true => 1, false => 1}
+    end
 
-  it "doesn't convert symbol or boolean to string when submitting update" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update(:test)
-    @stats.update(true)
-    @stats.update(false)
-    @stats.instance_variable_get(:@total).should == 3
-    @stats.instance_variable_get(:@count_per_type).should == {:test => 1, true => 1, false => 1}
-  end
+    it "converts arbitrary type value to limited-length string when submitting update" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update({1 => 11, 2 => 22})
+      @stats.update({1 => 11, 2 => 22, 3 => 12345678901234567890123456789012345678901234567890123456789})
+      @stats.instance_variable_get(:@total).should == 2
+      @stats.instance_variable_get(:@count_per_type).should == {"{1=>11, 2=>22}" => 1,
+                                                                "{1=>11, 2=>22, 3=>123456789012345678901234567890123456789..." => 1}
+    end
 
-  it "converts arbitrary type value to limited-length string when submitting update" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update({1 => 11, 2 => 22})
-    @stats.update({1 => 11, 2 => 22, 3 => 12345678901234567890123456789012345678901234567890123456789})
-    @stats.instance_variable_get(:@total).should == 2
-    @stats.instance_variable_get(:@count_per_type).should == {"{1=>11, 2=>22}" => 1,
-                                                              "{1=>11, 2=>22, 3=>123456789012345678901234567890123456789..." => 1}
+    it "doesn't measure rate if disabled" do
+      @stats = RightSupport::Stats::Activity.new(false)
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update
+      @stats.instance_variable_get(:@interval).should == 0.0
+      @stats.instance_variable_get(:@last_start_time).should == @now + 10
+      @stats.instance_variable_get(:@avg_duration).should be_nil
+      @stats.instance_variable_get(:@total).should == 1
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
   end
 
-  it "doesn't measure rate if disabled" do
-    @stats = RightSupport::Stats::Activity.new(false)
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update
-    @stats.instance_variable_get(:@interval).should == 0.0
-    @stats.instance_variable_get(:@last_start_time).should == @now + 10
-    @stats.instance_variable_get(:@avg_duration).should be_nil
-    @stats.instance_variable_get(:@total).should == 1
-    @stats.instance_variable_get(:@count_per_type).should == {}
-    @stats.all.should == {"last" => {"elapsed"=>0}, "total" => 1}
-  end
+  context :finish do
+    it "updates duration when finish using internal start time by default" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.avg_duration.should be_nil
+      @stats.finish
+      @stats.instance_variable_get(:@interval).should == 0.0
+      @stats.instance_variable_get(:@last_start_time).should == @now
+      @stats.instance_variable_get(:@avg_duration).should == 1.0
+      @stats.instance_variable_get(:@total).should == 0
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
 
-  it "updates duration when finish using internal start time by default" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.finish
-    @stats.instance_variable_get(:@interval).should == 0.0
-    @stats.instance_variable_get(:@last_start_time).should == @now
-    @stats.instance_variable_get(:@avg_duration).should == 1.0
-    @stats.instance_variable_get(:@total).should == 0
-    @stats.instance_variable_get(:@count_per_type).should == {}
+    it "updates duration when finish using specified start time" do
+      flexmock(Time).should_receive(:now).and_return(1000030)
+      @stats.avg_duration.should be_nil
+      @stats.finish(1000010)
+      @stats.instance_variable_get(:@interval).should == 0.0
+      @stats.instance_variable_get(:@last_start_time).should == @now
+      @stats.instance_variable_get(:@avg_duration).should == 2.0
+      @stats.instance_variable_get(:@total).should == 0
+      @stats.instance_variable_get(:@count_per_type).should == {}
+    end
   end
 
-  it "updates duration when finish using specified start time" do
-    flexmock(Time).should_receive(:now).and_return(1000030)
-    @stats.avg_duration.should be_nil
-    @stats.finish(1000010)
-    @stats.instance_variable_get(:@interval).should == 0.0
-    @stats.instance_variable_get(:@last_start_time).should == @now
-    @stats.instance_variable_get(:@avg_duration).should == 2.0
-    @stats.instance_variable_get(:@total).should == 0
-    @stats.instance_variable_get(:@count_per_type).should == {}
+  context :avg_rate do
+    it "converts interval to rate" do
+      flexmock(Time).should_receive(:now).and_return(1000020)
+      @stats.avg_rate.should be_nil
+      @stats.update
+      @stats.instance_variable_get(:@interval).should == 2.0
+      @stats.avg_rate.should == 0.5
+    end
   end
 
-  it "converts interval to rate" do
-    flexmock(Time).should_receive(:now).and_return(1000020)
-    @stats.avg_rate.should be_nil
-    @stats.update
-    @stats.instance_variable_get(:@interval).should == 2.0
-    @stats.avg_rate.should == 0.5
+  context :last do
+    it "reports number of seconds since last update or nil if no updates" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.last.should be_nil
+      @stats.update
+      @stats.last.should == {"elapsed" => 0}
+    end
+
+    it "reports number of seconds since last update and last type" do
+      @stats.update("test")
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.last.should == {"elapsed" => 10, "type" => "test"}
+    end
+
+    it "reports whether last activity is still active" do
+      @stats.update("test", "token")
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => true}
+      @stats.finish(@now - 10, "token")
+      @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => false}
+      @stats.instance_variable_get(:@avg_duration).should == 2.0
+    end
   end
 
-  it "reports number of seconds since last update or nil if no updates" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.last.should be_nil
-    @stats.update
-    @stats.last.should == {"elapsed" => 0}
+  context :percentage do
+    it "converts count per type to percentages" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update("foo")
+      @stats.instance_variable_get(:@total).should == 1
+      @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1}
+      @stats.percentage.should == {"total" => 1, "percent" => {"foo" => 100.0}}
+      @stats.update("bar")
+      @stats.instance_variable_get(:@total).should == 2
+      @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1, "bar" => 1}
+      @stats.percentage.should == {"total" => 2, "percent" => {"foo" => 50.0, "bar" => 50.0}}
+      @stats.update("foo")
+      @stats.update("foo")
+      @stats.instance_variable_get(:@total).should == 4
+      @stats.instance_variable_get(:@count_per_type).should == {"foo" => 3, "bar" => 1}
+      @stats.percentage.should == {"total" => 4, "percent" => {"foo" => 75.0, "bar" => 25.0}}
+    end
   end
 
-  it "reports number of seconds since last update and last type" do
-    @stats.update("test")
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.last.should == {"elapsed" => 10, "type" => "test"}
+  context :all do
+    it "returns all activity aspects that were measured except duration" do
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update
+      @stats.all.should == {"last" => {"elapsed" => 0}, "total" => 1, "rate" => 1.0}
+    end
+
+    it "excludes rate if it is not being measured" do
+      @stats = RightSupport::Stats::Activity.new(false)
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      @stats.update
+      @stats.all.should == {"last" => {"elapsed" => 0}, "total" => 1}
+    end
+
+    it "includes percentage breakdown when update recorded per type" do
+      @stats = RightSupport::Stats::Activity.new(false)
+      flexmock(Time).should_receive(:now).and_return(1000010, 1000010, 1000020, 1000020, 1000030, 1000030, 1000040)
+      @stats.update("foo")
+      @stats.all.should == {"last" => {"elapsed" => 0, "type" => "foo"}, "total" => 1, "percent" => {"foo" => 100.0}}
+      @stats.update("bar")
+      @stats.all.should == {"last" => {"elapsed" => 0, "type" => "bar"}, "total" => 2, "percent" => {"foo" => 50.0, "bar" => 50.0}}
+      @stats.update("bar")
+      @stats.update("foo")
+      @stats.all.should == {"last" => {"elapsed" => 10, "type" => "foo"}, "total" => 4, "percent" => {"foo" => 50.0, "bar" => 50.0}}
+    end
+
+    it "returns nil if there was no activity" do
+      @stats.all.should be_nil
+    end
   end
 
-  it "reports whether last activity is still active" do
-    @stats.update("test", "token")
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => true}
-    @stats.finish(@now - 10, "token")
-    @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => false}
-    @stats.instance_variable_get(:@avg_duration).should == 2.0
+  context :average do
+    it "weights average toward past activity" do
+      @stats.send(:average, 0.0, 10.0).should == 1.0
+      @stats.send(:average, 1.0, 10.0).should == 1.9
+      @stats.send(:average, 1.9, 10.0).should == 2.71
+      @stats.send(:average, 2.71, 10.0).should == 3.439
+      @stats.send(:average, 3.439, 10.0).should == 4.0951
+      @stats.send(:average, 4.0951, 10.0).should == 4.68559
+      @stats.send(:average, 4.68559, 10.0).should == 5.217031
+    end
   end
 
-  it "converts count per type to percentages" do
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    @stats.update("foo")
-    @stats.instance_variable_get(:@total).should == 1
-    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1}
-    @stats.percentage.should == {"total" => 1, "percent" => {"foo" => 100.0}}
-    @stats.update("bar")
-    @stats.instance_variable_get(:@total).should == 2
-    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1, "bar" => 1}
-    @stats.percentage.should == {"total" => 2, "percent" => {"foo" => 50.0, "bar" => 50.0}}
-    @stats.update("foo")
-    @stats.update("foo")
-    @stats.instance_variable_get(:@total).should == 4
-    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 3, "bar" => 1}
-    @stats.percentage.should == {"total" => 4, "percent" => {"foo" => 75.0, "bar" => 25.0}}
+  describe "class methods" do
+
+    context :all do
+      it "aggregates stats from multiple all calls" do
+        stats = [{"last" => {"elapsed" => 10, "type" => "foo"}, "total" => 1, "percent" => {"foo" => 100.0}},
+                 {"last" => {"elapsed" => 20, "type" => "bar"}, "total" => 4, "percent" => {"bar" => 100.0}}]
+        RightSupport::Stats::Activity.all(stats).should ==
+            {"last" => {"elapsed" => 10, "type" => "foo"}, "total" => 5, "percent" => {"foo" => 20.0, "bar" => 80.0}}
+      end
+
+      it "includes rate if provided" do
+        stats = [{"last" => {"elapsed" => 10, "type" => "foo"}, "total" => 1, "percent" => {"foo" => 100.0}, "rate" => 0.5},
+                 {"last" => {"elapsed" => 20, "type" => "bar"}, "total" => 4, "percent" => {"bar" => 100.0}, "rate" => 0.1}]
+        RightSupport::Stats::Activity.all(stats).should ==
+            {"last" => {"elapsed" => 10, "type" => "foo"}, "total" => 5, "percent" => {"foo" => 20.0, "bar" => 80.0}, "rate" => 0.18}
+      end
+
+      it "returns nil if there are no stats" do
+        RightSupport::Stats::Activity.all([]).should be_nil
+      end
+    end
+
+    context :percentage do
+      it "aggregates multiple percentage stats" do
+        stats = [{"total" => 1, "percent" => {"foo" => 100.0}},
+                 {"total" => 5, "percent" => {"bar" => 100.0}},
+                 {"total" => 4, "percent" => {"foo" => 75.0, "bar" => 25.0}}]
+        RightSupport::Stats::Activity.percentage(stats, 10).should == {"total" => 10, "percent" => {"foo" => 40.0, "bar" => 60.0}}
+      end
+
+      it "returns only total if there is no data" do
+        RightSupport::Stats::Activity.percentage([], 0).should == {"total" => 0}
+      end
+    end
+
+    context :avg_rate do
+      it "computes average rate from multiple average rates" do
+        stats = [{"total" => 1, "rate" => 0.5},
+                 {"total" => 5, "rate" => 0.1},
+                 {"total" => 4, "rate" => 0.2}]
+        RightSupport::Stats::Activity.avg_rate(stats, 10).should == 0.18
+      end
+
+      it "returns nil if there is no data" do
+        RightSupport::Stats::Activity.avg_rate([], 0).should be_nil
+      end
+    end
+
+    context :last do
+      it "determines last activity from multiple last activity stats" do
+        stats = [{"last" => {"elapsed" => 0, "type" => "foo"}, "total" => 1, "percent" => {"foo" => 100.0}},
+                 {"last" => {"elapsed" => 0, "type" => "foo"}, "total" => 1, "percent" => {"foo" => 100.0}}]
+      end
+
+      it "returns nil if there is no data" do
+        RightSupport::Stats::Activity.last([]).should be_nil
+      end
+    end
   end
 
 end # RightSupport::Stats::Activity

data/spec/stats/exceptions_spec.rb

@@ -33,90 +33,196 @@ describe RightSupport::Stats::Exceptions do
     @exception = Exception.new("Test error")
   end
 
-  it "initializes stats data" do
-    @stats.stats.should be_nil
-    @stats.instance_variable_get(:@callback).should be_nil
+  context :initialize do
+    it "initializes stats data" do
+      @stats.stats.should be_nil
+      @stats.instance_variable_get(:@callback).should be_nil
+    end
   end
 
-  it "tracks submitted exception information by category" do
-    @stats.track("testing", @exception)
-    @stats.stats.should == {"testing" => {"total" => 1,
-                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
-                                                        "when" => @now, "where" => nil}]}}
+  context :reset do
+    it "clears any currently stored exceptions" do
+      @stats.track("testing", @exception)
+      @stats.stats.should_not be_nil
+      @stats.reset
+      @stats.stats.should be_nil
+    end
   end
 
-  it "recognizes and counts repeated exceptions" do
-    @stats.track("testing", @exception)
-    @stats.stats.should == {"testing" => {"total" => 1,
-                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
-                                                        "when" => @now, "where" => nil}]}}
-    flexmock(Time).should_receive(:now).and_return(1000010)
-    category = "another"
-    backtrace = ["here", "and", "there"]
-    4.times do |i|
+  context :track do
+    it "tracks submitted exception information by category" do
+      @stats.track("testing", @exception)
+      @stats.stats.should == {"testing" => {"total" => 1,
+                                            "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                          "when" => @now, "where" => nil}]}}
+    end
+
+    it "tracks where exception occurred if it has a backtrace" do
       begin
-        raise ArgumentError, "badarg"
+        raise Exception.new("Test error")
       rescue Exception => e
-        flexmock(e).should_receive(:backtrace).and_return(backtrace)
-        @stats.track(category, e)
-        backtrace.shift(2) if i == 1
-        category = "testing" if i == 2
+        @exception = e
       end
+      @stats.track("testing", @exception)
+      @stats.stats["testing"]["recent"][0]["where"].should =~ /right_support\/spec\/stats\/exceptions_spec.rb/
+    end
+
+    it "recognizes and counts repeated exceptions" do
+      @stats.track("testing", @exception)
+      @stats.stats.should == {"testing" => {"total" => 1,
+                                            "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                          "when" => @now, "where" => nil}]}}
+      flexmock(Time).should_receive(:now).and_return(1000010)
+      category = "another"
+      backtrace = ["here", "and", "there"]
+      4.times do |i|
+        begin
+          raise ArgumentError, "badarg"
+        rescue Exception => e
+          flexmock(e).should_receive(:backtrace).and_return(backtrace)
+          @stats.track(category, e)
+          backtrace.shift(2) if i == 1
+          category = "testing" if i == 2
+        end
+      end
+      @stats.stats.should == {"testing" => {"total" => 2,
+                                            "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                          "when" => @now, "where" => nil},
+                                                         {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                                          "when" => @now + 10, "where" => "there"}]},
+                              "another" => {"total" => 3,
+                                            "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                                          "when" => @now + 10, "where" => "here"},
+                                                         {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                                          "when" => @now + 10, "where" => "there"}]}}
+    end
+
+    it "limits the number of exceptions stored by eliminating older exceptions" do
+      (RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1).times do |i|
+        begin
+          raise ArgumentError, "badarg"
+        rescue Exception => e
+          flexmock(e).should_receive(:backtrace).and_return([i.to_s])
+          @stats.track("testing", e)
+        end
+      end
+      stats = @stats.stats
+      stats["testing"]["total"].should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1
+      stats["testing"]["recent"].size.should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS
+      stats["testing"]["recent"][0]["where"].should == "1"
+    end
+
+    it "makes callback if callback and message defined" do
+      called = 0
+      callback = lambda do |exception, message, server|
+        called += 1
+        exception.should == @exception
+        message.should == "message"
+        server.should == "server"
+      end
+      @stats = RightSupport::Stats::Exceptions.new("server", callback)
+      @stats.track("testing", @exception, "message")
+      @stats.stats.should == {"testing" => {"total" => 1,
+                                            "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                          "when" => @now, "where" => nil}]}}
+      called.should == 1
     end
-    @stats.stats.should == {"testing" => {"total" => 2,
-                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
-                                                        "when" => @now, "where" => nil},
-                                                       {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
-                                                        "when" => @now + 10, "where" => "there"}]},
-                            "another" => {"total" => 3,
-                                          "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
-                                                        "when" => @now + 10, "where" => "here"},
-                                                       {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
-                                                        "when" => @now + 10, "where" => "there"}]}}
-  end
 
-  it "limits the number of exceptions stored by eliminating older exceptions" do
-    (RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1).times do |i|
+    it "catches any exceptions raised internally and log them" do
       begin
-        raise ArgumentError, "badarg"
-      rescue Exception => e
-        flexmock(e).should_receive(:backtrace).and_return([i.to_s])
-        @stats.track("testing", e)
+        logger = flexmock("logger")
+        logger.should_receive(:error).with(/Failed to track exception 'Test error' \(Exception: bad IN/).once
+        RightSupport::Log::Mixin.default_logger = logger
+        flexmock(@exception).should_receive(:backtrace).and_raise(Exception.new("bad"))
+        @stats = RightSupport::Stats::Exceptions.new
+        @stats.track("testing", @exception, "message")
+        @stats.stats["testing"]["total"].should == 1
+      ensure
+        RightSupport::Log::Mixin.default_logger = nil
       end
     end
-    stats = @stats.stats
-    stats["testing"]["total"].should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1
-    stats["testing"]["recent"].size.should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS
-    stats["testing"]["recent"][0]["where"].should == "1"
   end
 
-  it "makes callback if callback and message defined" do
-    called = 0
-    callback = lambda do |exception, message, server|
-      called += 1
-      exception.should == @exception
-      message.should == "message"
-      server.should == "server"
-    end
-    @stats = RightSupport::Stats::Exceptions.new("server", callback)
-    @stats.track("testing", @exception, "message")
-    @stats.stats.should == {"testing" => {"total" => 1,
+  context :all do
+    it "returns current stats" do
+      @stats.track("testing", @exception)
+      @stats.all.should == {"testing" => {"total" => 1,
                                           "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
                                                         "when" => @now, "where" => nil}]}}
-    called.should == 1
+    end
+
+    it "returns nil if there are no stats" do
+      @stats.all.should be_nil
+    end
   end
 
-  it "catches any exceptions raised internally and log them" do
-    begin
-      logger = flexmock("logger")
-      logger.should_receive(:error).with(/Failed to track exception 'Test error' \(Exception: bad IN/).once
-      RightSupport::Log::Mixin.default_logger = logger
-      flexmock(@exception).should_receive(:backtrace).and_raise(Exception.new("bad"))
-      @stats = RightSupport::Stats::Exceptions.new
-      @stats.track("testing", @exception, "message")
-      @stats.stats["testing"]["total"].should == 1
-    ensure
-      RightSupport::Log::Mixin.default_logger = nil
+  describe "class methods" do
+
+    context :all do
+      before(:each) do
+
+      end
+
+      it "aggregates the stats from multiple all calls" do
+        stats = [{"testing" => {"total" => 3,
+                                "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                              "when" => @now, "where" => nil},
+                                             {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 20, "where" => "there"},
+                                             {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 30, "where" => "everywhere"}]}},
+                 {"testing" => {"total" => 5,
+                                "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 10, "where" => "here"},
+                                             {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 15, "where" => "there"},
+                                             {"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 30, "where" => "everywhere"}]}},
+                 {"testing" => {"total" => 1,
+                                "recent" => [{"count" => 1, "type" => "ArgumentError", "message" => "awfularg",
+                                              "when" => @now + 10, "where" => "here"}]}},
+                 {"another" => {"total" => 3,
+                                "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 10, "where" => "here"},
+                                             {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                              "when" => @now + 10, "where" => "there"}]}}]
+
+        RightSupport::Stats::Exceptions.all(stats).should ==
+            {"testing" => {"total" => 9,
+                           "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                         "when" => @now, "where" => nil},
+                                        {"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 10, "where" => "here"},
+                                        {"count" => 1, "type" => "ArgumentError", "message" => "awfularg",
+                                         "when" => @now + 10, "where" => "here"},
+                                        {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 15, "where" => "there"},
+                                        {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 20, "where" => "there"},
+                                        {"count" => 3, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 30, "where" => "everywhere"}]},
+             "another" => {"total" => 3,
+                           "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 10, "where" => "here"},
+                                        {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                         "when" => @now + 10, "where" => "there"}]}}
+      end
+
+      it "does not allow max exceptions to exceed set limit" do
+        max = RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS
+        stats = []
+        ((max / 2) + 1).times do |i|
+          stats << {"testing" => {"total" => 1,
+                                  "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                "when" => @now + i, "where" => nil},
+                                               {"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                                "when" => @now + i, "where" => "here"}]}}
+        end
+        all = RightSupport::Stats::Exceptions.all(stats)
+        all["testing"]["recent"].size.should == max
+        all["testing"]["recent"][max - 1].should == {"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                                     "when" => @now + (max / 2), "where" => "here"}
+      end
     end
   end