public void RollingNumber_MaxValue() { MockedTime time = new MockedTime(); try { HystrixRollingNumberEvent type = HystrixRollingNumberEvent.ThreadMaxActive; HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); counter.UpdateRollingMax(type, 10); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 30); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 40); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 15); Assert.AreEqual(40, counter.GetRollingMaxValue(type)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CounterRetrievalRefreshesBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // we should have 1 bucket since nothing has triggered the update of buckets in the elapsed time Assert.AreEqual(1, counter.Buckets.Size); // the total counts Assert.AreEqual(4, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(2, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); // we should have 4 buckets as the counter 'gets' should have triggered the buckets being created to fill in time Assert.AreEqual(4, counter.Buckets.Size); // wait until window passes time.Increment(counter.TimeInMilliseconds); // the total counts should all be 0 (and the buckets cleared by the get, not only increment) Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); // increment counter.Increment(HystrixRollingNumberEvent.Success); // the total counts should now include only the last bucket after a reset since the window passed Assert.AreEqual(1, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CreatesBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // confirm the initial settings Assert.AreEqual(200, counter.TimeInMilliseconds); Assert.AreEqual(10, counter.NumberOfBuckets); Assert.AreEqual(20, counter.BucketSizeInMilliseconds); // we start out with 0 buckets in the queue Assert.AreEqual(0, counter.Buckets.Size); // add a success in each interval which should result in all 10 buckets being created with 1 success in each for (int i = 0; i < counter.NumberOfBuckets; i++) { counter.Increment(HystrixRollingNumberEvent.Success); time.Increment(counter.BucketSizeInMilliseconds); } // confirm we have all 10 buckets Assert.AreEqual(10, counter.Buckets.Size); // add 1 more and we should still only have 10 buckets since that's the max counter.Increment(HystrixRollingNumberEvent.Success); Assert.AreEqual(10, counter.Buckets.Size); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CreatesBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // confirm the initial settings Assert.AreEqual(200, counter.TimeInMilliseconds); Assert.AreEqual(10, counter.NumberOfBuckets); Assert.AreEqual(20, counter.BucketSizeInMilliseconds); // we start out with 0 buckets in the queue Assert.AreEqual(0, counter.Buckets.Size); // add a success in each interval which should result in all 10 buckets being created with 1 success in each for (int i = 0; i < counter.NumberOfBuckets; i++) { counter.Increment(HystrixRollingNumberEvent.Success); time.Increment(counter.BucketSizeInMilliseconds); } // confirm we have all 10 buckets Assert.AreEqual(10, counter.Buckets.Size); // add 1 more and we should still only have 10 buckets since that's the max counter.Increment(HystrixRollingNumberEvent.Success); Assert.AreEqual(10, counter.Buckets.Size); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_Rolling() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.ThreadMaxActive; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.GetCurrentBucket(); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); // System.out.println("Head: " + counter.Buckets.state.Get().head); // System.out.println("Tail: " + counter.Buckets.state.Get().tail); } }
public void RollingNumber_CumulativeCounterAfterRolling() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.Increment(type); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); } // cumulative count should be 20 (for the number of loops above) regardless of buckets rolling Assert.AreEqual(20, counter.GetCumulativeSum(type)); }
public void RollingNumber_CumulativeCounterAfterRollingAndReset3() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); counter.Increment(type); counter.Increment(type); counter.Increment(type); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } } // since we are rolling over the buckets it should reset naturally // no increments during the loop, just some before and after counter.Increment(type); counter.Increment(type); // cumulative count should be 5 regardless of buckets rolling Assert.AreEqual(5, counter.GetCumulativeSum(type)); }
public void RollingNumber_EmptyBucketsFillIn() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // add 1 counter.Increment(HystrixRollingNumberEvent.Success); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // wait past 3 bucket time periods (the 1st bucket then 2 empty ones) time.Increment(counter.BucketSizeInMilliseconds * 3); // add another counter.Increment(HystrixRollingNumberEvent.Success); // we should have 4 (1 + 2 empty + 1 new one) buckets Assert.AreEqual(4, counter.Buckets.Size); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_UpdateMax2() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 10); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 20); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // the count should be 30 Assert.AreEqual(30, counter.Buckets.GetLast().GetMaxUpdater(HystrixRollingNumberEvent.ThreadMaxActive).Max()); Assert.AreEqual(30, counter.GetRollingMaxValue(HystrixRollingNumberEvent.ThreadMaxActive)); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 50); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the count Assert.AreEqual(50, counter.Buckets.GetLast().GetMaxUpdater(HystrixRollingNumberEvent.ThreadMaxActive).Max()); Assert.AreEqual(50, counter.GetValueOfLatestBucket(HystrixRollingNumberEvent.ThreadMaxActive)); // values per bucket long[] values = counter.GetValues(HystrixRollingNumberEvent.ThreadMaxActive); Assert.AreEqual(30, values[0]); // oldest bucket Assert.AreEqual(0, values[1]); Assert.AreEqual(0, values[2]); Assert.AreEqual(50, values[3]); // latest bucket } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CumulativeCounterAfterRollingAndReset2() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); counter.Increment(type); counter.Increment(type); counter.Increment(type); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } if (i == 5 || i == 15) { // simulate a reset occurring every once in a while // so we ensure the absolute sum is handling it okay counter.Reset(); } } // no increments during the loop, just some before and after counter.Increment(type); counter.Increment(type); // cumulative count should be 5 regardless of buckets rolling Assert.AreEqual(5, counter.GetCumulativeSum(type)); }
private void TestCounterType(HystrixRollingNumberEvent type) { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(type); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // the count should be 1 Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(type).Sum()); Assert.AreEqual(1, counter.GetRollingSum(type)); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // increment again in latest bucket counter.Increment(type); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the counts of the last bucket Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(type).Sum()); // the total counts Assert.AreEqual(2, counter.GetRollingSum(type)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CumulativeCounterAfterRollingAndReset() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.Increment(type); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); if (i == 5 || i == 15) { // simulate a reset occurring every once in a while // so we ensure the absolute sum is handling it okay counter.Reset(); } } // cumulative count should be 20 (for the number of loops above) regardless of buckets rolling Assert.AreEqual(20, counter.GetCumulativeSum(type)); }
public void RollingPercentile_Rolling() { MockedTime time = new MockedTime(); HystrixRollingPercentile p = new HystrixRollingPercentile(time, timeInMilliseconds, numberOfBuckets, bucketDataLength, enabled); p.AddValue(1000); p.AddValue(1000); p.AddValue(1000); p.AddValue(2000); Assert.AreEqual(1, p.Buckets.Size); // no bucket turnover yet so percentile not yet generated Assert.AreEqual(0, p.GetPercentile(50)); time.Increment(6000); // still only 1 bucket until we touch it again Assert.AreEqual(1, p.Buckets.Size); // a bucket has been created so we have a new percentile Assert.AreEqual(1000, p.GetPercentile(50)); // now 2 buckets since getting a percentile causes bucket retrieval Assert.AreEqual(2, p.Buckets.Size); p.AddValue(1000); p.AddValue(500); // should still be 2 buckets Assert.AreEqual(2, p.Buckets.Size); p.AddValue(200); p.AddValue(200); p.AddValue(1600); p.AddValue(200); p.AddValue(1600); p.AddValue(1600); // we haven't progressed to a new bucket so the percentile should be the same and ignore the most recent bucket Assert.AreEqual(1000, p.GetPercentile(50)); // increment to another bucket so we include all of the above in the PercentileSnapshot time.Increment(6000); // the rolling version should have the same data as creating a snapshot like this HystrixRollingPercentile.PercentileSnapshot ps = new HystrixRollingPercentile.PercentileSnapshot(1000, 1000, 1000, 2000, 1000, 500, 200, 200, 1600, 200, 1600, 1600); Assert.AreEqual(ps.GetPercentile(0.15), p.GetPercentile(0.15)); Assert.AreEqual(ps.GetPercentile(0.50), p.GetPercentile(0.50)); Assert.AreEqual(ps.GetPercentile(0.90), p.GetPercentile(0.90)); Assert.AreEqual(ps.GetPercentile(0.995), p.GetPercentile(0.995)); TestContext.WriteLine("100th: " + ps.GetPercentile(100) + " " + p.GetPercentile(100)); TestContext.WriteLine("99.5th: " + ps.GetPercentile(99.5) + " " + p.GetPercentile(99.5)); TestContext.WriteLine("99th: " + ps.GetPercentile(99) + " " + p.GetPercentile(99)); TestContext.WriteLine("90th: " + ps.GetPercentile(90) + " " + p.GetPercentile(90)); TestContext.WriteLine("50th: " + ps.GetPercentile(50) + " " + p.GetPercentile(50)); TestContext.WriteLine("10th: " + ps.GetPercentile(10) + " " + p.GetPercentile(10)); // mean = 1000+1000+1000+2000+1000+500+200+200+1600+200+1600+1600/12 Assert.AreEqual(991, ps.Mean); }
public void RollingPercentile_DoesNothingWhenDisabled() { MockedTime time = new MockedTime(); int previousTime = 0; HystrixRollingPercentile p = new HystrixRollingPercentile(time, timeInMilliseconds, numberOfBuckets, bucketDataLength, HystrixPropertyFactory.AsProperty(false)); int length = SampleData2.GetLength(0); for (int i = 0; i < length; i++) { int timeInMillisecondsSinceStart = SampleData2[i, 0]; int latency = SampleData2[i, 1]; time.Increment(timeInMillisecondsSinceStart - previousTime); previousTime = timeInMillisecondsSinceStart; p.AddValue(latency); } Assert.AreEqual(-1, p.GetPercentile(50)); Assert.AreEqual(-1, p.GetPercentile(75)); Assert.AreEqual(-1, p.GetMean()); }
public void RollingPercentile_ValueIsZeroAfterRollingWindowPassesAndNoTraffic() { MockedTime time = new MockedTime(); HystrixRollingPercentile p = new HystrixRollingPercentile(time, timeInMilliseconds, numberOfBuckets, bucketDataLength, enabled); p.AddValue(1000); p.AddValue(1000); p.AddValue(1000); p.AddValue(2000); p.AddValue(4000); Assert.AreEqual(1, p.Buckets.Size); // no bucket turnover yet so percentile not yet generated Assert.AreEqual(0, p.GetPercentile(50)); time.Increment(6000); // still only 1 bucket until we touch it again Assert.AreEqual(1, p.Buckets.Size); // a bucket has been created so we have a new percentile Assert.AreEqual(1500, p.GetPercentile(50)); // let 1 minute pass time.Increment(60000); // no data in a minute should mean all buckets are empty (or reset) so we should not have any percentiles Assert.AreEqual(0, p.GetPercentile(50)); }
private void TestCounterType(HystrixRollingNumberEvent type) { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(type); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // the count should be 1 Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(type).Sum()); Assert.AreEqual(1, counter.GetRollingSum(type)); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // increment again in latest bucket counter.Increment(type); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the counts of the last bucket Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(type).Sum()); // the total counts Assert.AreEqual(2, counter.GetRollingSum(type)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_IncrementInMultipleBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.ShortCircuited); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.ShortCircuited); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the counts of the last bucket Assert.AreEqual(2, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Success).Sum()); Assert.AreEqual(3, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Failure).Sum()); Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Timeout).Sum()); Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.ShortCircuited).Sum()); // the total counts Assert.AreEqual(6, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(5, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); Assert.AreEqual(3, counter.GetRollingSum(HystrixRollingNumberEvent.Timeout)); Assert.AreEqual(2, counter.GetRollingSum(HystrixRollingNumberEvent.ShortCircuited)); // wait until window passes time.Increment(counter.TimeInMilliseconds); // increment counter.Increment(HystrixRollingNumberEvent.Success); // the total counts should now include only the last bucket after a reset since the window passed Assert.AreEqual(1, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Timeout)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_IncrementInMultipleBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.ShortCircuited); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Timeout); counter.Increment(HystrixRollingNumberEvent.ShortCircuited); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the counts of the last bucket Assert.AreEqual(2, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Success).Sum()); Assert.AreEqual(3, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Failure).Sum()); Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Timeout).Sum()); Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.ShortCircuited).Sum()); // the total counts Assert.AreEqual(6, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(5, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); Assert.AreEqual(3, counter.GetRollingSum(HystrixRollingNumberEvent.Timeout)); Assert.AreEqual(2, counter.GetRollingSum(HystrixRollingNumberEvent.ShortCircuited)); // wait until window passes time.Increment(counter.TimeInMilliseconds); // increment counter.Increment(HystrixRollingNumberEvent.Success); // the total counts should now include only the last bucket after a reset since the window passed Assert.AreEqual(1, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Timeout)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_Rolling() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.ThreadMaxActive; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.GetCurrentBucket(); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); // System.out.println("Head: " + counter.Buckets.state.Get().head); // System.out.println("Tail: " + counter.Buckets.state.Get().tail); } }
public void RollingNumber_CounterRetrievalRefreshesBuckets() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Success); counter.Increment(HystrixRollingNumberEvent.Failure); counter.Increment(HystrixRollingNumberEvent.Failure); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); // we should have 1 bucket since nothing has triggered the update of buckets in the elapsed time Assert.AreEqual(1, counter.Buckets.Size); // the total counts Assert.AreEqual(4, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(2, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); // we should have 4 buckets as the counter 'gets' should have triggered the buckets being created to fill in time Assert.AreEqual(4, counter.Buckets.Size); // wait until window passes time.Increment(counter.TimeInMilliseconds); // the total counts should all be 0 (and the buckets cleared by the get, not only increment) Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); // increment counter.Increment(HystrixRollingNumberEvent.Success); // the total counts should now include only the last bucket after a reset since the window passed Assert.AreEqual(1, counter.GetRollingSum(HystrixRollingNumberEvent.Success)); Assert.AreEqual(0, counter.GetRollingSum(HystrixRollingNumberEvent.Failure)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_EmptyBucketsFillIn() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // add 1 counter.Increment(HystrixRollingNumberEvent.Success); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // wait past 3 bucket time periods (the 1st bucket then 2 empty ones) time.Increment(counter.BucketSizeInMilliseconds * 3); // add another counter.Increment(HystrixRollingNumberEvent.Success); // we should have 4 (1 + 2 empty + 1 new one) buckets Assert.AreEqual(4, counter.Buckets.Size); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CumulativeCounterAfterRollingAndReset3() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); counter.Increment(type); counter.Increment(type); counter.Increment(type); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } } // since we are rolling over the buckets it should reset naturally // no increments during the loop, just some before and after counter.Increment(type); counter.Increment(type); // cumulative count should be 5 regardless of buckets rolling Assert.AreEqual(5, counter.GetCumulativeSum(type)); }
public void RollingPercentile_SampleDataOverTime2() { TestContext.WriteLine("\n\n***************************** testSampleDataOverTime2 \n"); MockedTime time = new MockedTime(); int previousTime = 0; HystrixRollingPercentile p = new HystrixRollingPercentile(time, timeInMilliseconds, numberOfBuckets, bucketDataLength, enabled); int length = SampleData2.GetLength(0); for (int i = 0; i < length; i++) { int timeInMillisecondsSinceStart = SampleData2[i, 0]; int latency = SampleData2[i, 1]; time.Increment(timeInMillisecondsSinceStart - previousTime); previousTime = timeInMillisecondsSinceStart; p.AddValue(latency); } TestContext.WriteLine("0.01: " + p.GetPercentile(0.01)); TestContext.WriteLine("Median: " + p.GetPercentile(50)); TestContext.WriteLine("90th: " + p.GetPercentile(90)); TestContext.WriteLine("99th: " + p.GetPercentile(99)); TestContext.WriteLine("99.5th: " + p.GetPercentile(99.5)); TestContext.WriteLine("99.99: " + p.GetPercentile(99.99)); if (p.GetPercentile(50) > 90 || p.GetPercentile(50) < 50) { Assert.Fail("We expect around 60-70 but got: " + p.GetPercentile(50)); } if (p.GetPercentile(99) < 400) { Assert.Fail("We expect to see some high values over 400 but got: " + p.GetPercentile(99)); } }
public void RollingNumber_UpdateMax2() { MockedTime time = new MockedTime(); try { HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); // increment counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 10); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 20); // we should have 1 bucket Assert.AreEqual(1, counter.Buckets.Size); // the count should be 30 Assert.AreEqual(30, counter.Buckets.GetLast().GetMaxUpdater(HystrixRollingNumberEvent.ThreadMaxActive).Max()); Assert.AreEqual(30, counter.GetRollingMaxValue(HystrixRollingNumberEvent.ThreadMaxActive)); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds * 3); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 30); counter.UpdateRollingMax(HystrixRollingNumberEvent.ThreadMaxActive, 50); // we should have 4 buckets Assert.AreEqual(4, counter.Buckets.Size); // the count Assert.AreEqual(50, counter.Buckets.GetLast().GetMaxUpdater(HystrixRollingNumberEvent.ThreadMaxActive).Max()); Assert.AreEqual(50, counter.GetValueOfLatestBucket(HystrixRollingNumberEvent.ThreadMaxActive)); // values per bucket long[] values = counter.GetValues(HystrixRollingNumberEvent.ThreadMaxActive); Assert.AreEqual(30, values[0]); // oldest bucket Assert.AreEqual(0, values[1]); Assert.AreEqual(0, values[2]); Assert.AreEqual(50, values[3]); // latest bucket } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CumulativeCounterAfterRolling() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.Increment(type); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); } // cumulative count should be 20 (for the number of loops above) regardless of buckets rolling Assert.AreEqual(20, counter.GetCumulativeSum(type)); }
public void RollingNumber_CumulativeCounterAfterRollingAndReset() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { // first bucket counter.Increment(type); try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } Assert.AreEqual(2, counter.GetValues(type).Length); counter.GetValueOfLatestBucket(type); if (i == 5 || i == 15) { // simulate a reset occurring every once in a while // so we ensure the absolute sum is handling it okay counter.Reset(); } } // cumulative count should be 20 (for the number of loops above) regardless of buckets rolling Assert.AreEqual(20, counter.GetCumulativeSum(type)); }
public void RollingNumber_MaxValue() { MockedTime time = new MockedTime(); try { HystrixRollingNumberEvent type = HystrixRollingNumberEvent.ThreadMaxActive; HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10); counter.UpdateRollingMax(type, 10); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 30); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 40); // sleep to get to a new bucket time.Increment(counter.BucketSizeInMilliseconds); counter.UpdateRollingMax(type, 15); Assert.AreEqual(40, counter.GetRollingMaxValue(type)); } catch (Exception e) { TestContext.WriteLine(e.ToString()); Assert.Fail("Exception: " + e.Message); } }
public void RollingNumber_CumulativeCounterAfterRollingAndReset2() { MockedTime time = new MockedTime(); HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Success; HystrixRollingNumber counter = new HystrixRollingNumber(time, 20, 2); Assert.AreEqual(0, counter.GetCumulativeSum(type)); counter.Increment(type); counter.Increment(type); counter.Increment(type); // iterate over 20 buckets on a queue sized for 2 for (int i = 0; i < 20; i++) { try { time.Increment(counter.BucketSizeInMilliseconds); } catch (Exception) { // ignore } if (i == 5 || i == 15) { // simulate a reset occurring every once in a while // so we ensure the absolute sum is handling it okay counter.Reset(); } } // no increments during the loop, just some before and after counter.Increment(type); counter.Increment(type); // cumulative count should be 5 regardless of buckets rolling Assert.AreEqual(5, counter.GetCumulativeSum(type)); }
public void RollingPercentile_SampleDataOverTime1() { TestContext.WriteLine("\n\n***************************** testSampleDataOverTime1 \n"); MockedTime time = new MockedTime(); HystrixRollingPercentile p = new HystrixRollingPercentile(time, timeInMilliseconds, numberOfBuckets, bucketDataLength, enabled); int previousTime = 0; int length = SampleData1.GetLength(0); for (int i = 0; i < length; i++) { int timeInMillisecondsSinceStart = SampleData1[i, 0]; int latency = SampleData1[i, 1]; time.Increment(timeInMillisecondsSinceStart - previousTime); previousTime = timeInMillisecondsSinceStart; p.AddValue(latency); } TestContext.WriteLine("0.01: " + p.GetPercentile(0.01)); TestContext.WriteLine("Median: " + p.GetPercentile(50)); TestContext.WriteLine("90th: " + p.GetPercentile(90)); TestContext.WriteLine("99th: " + p.GetPercentile(99)); TestContext.WriteLine("99.5th: " + p.GetPercentile(99.5)); TestContext.WriteLine("99.99: " + p.GetPercentile(99.99)); TestContext.WriteLine("Median: " + p.GetPercentile(50)); TestContext.WriteLine("Median: " + p.GetPercentile(50)); TestContext.WriteLine("Median: " + p.GetPercentile(50)); /* * In a loop as a use case was found where very different values were calculated in subsequent requests. */ for (int i = 0; i < 10; i++) { if (p.GetPercentile(50) > 5) { Assert.Fail("We expect around 2 but got: " + p.GetPercentile(50)); } if (p.GetPercentile(99.5) < 20) { Assert.Fail("We expect to see some high values over 20 but got: " + p.GetPercentile(99.5)); } } }