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 TestIncrementInSingleBucket()
{
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);
// we should have 1 bucket
Assert.Equal(1, counter._buckets.Size);
// the count should be 4
Assert.Equal(4, counter._buckets.Last.GetAdder(HystrixRollingNumberEvent.SUCCESS).Sum());
Assert.Equal(2, counter._buckets.Last.GetAdder(HystrixRollingNumberEvent.FAILURE).Sum());
Assert.Equal(1, counter._buckets.Last.GetAdder(HystrixRollingNumberEvent.TIMEOUT).Sum());
}
catch (Exception e)
{
output.WriteLine(e.ToString());
Assert.True(false, "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_ResetBuckets()
{
MockedTime time = new MockedTime();
try
{
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
// we start out with 0 buckets in the queue
Assert.AreEqual(0, counter.Buckets.Size);
// add 1
counter.Increment(HystrixRollingNumberEvent.Success);
// confirm we have 1 bucket
Assert.AreEqual(1, counter.Buckets.Size);
// confirm we still have 1 bucket
Assert.AreEqual(1, counter.Buckets.Size);
// add 1
counter.Increment(HystrixRollingNumberEvent.Success);
// we should now have a single bucket with no values in it instead of 2 or more buckets
Assert.AreEqual(1, counter.Buckets.Size);
}
catch (Exception e)
{
TestContext.WriteLine(e.ToString());
Assert.Fail("Exception: " + e.Message);
}
}
public void TestMaxValue()
{
MockedTime time = new MockedTime();
try
{
HystrixRollingNumberEvent type = HystrixRollingNumberEvent.THREAD_MAX_ACTIVE;
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
counter.UpdateRollingMax(type, 10);
// sleep to get to a new bucket
time.Increment(counter._bucketSizeInMillseconds);
counter.UpdateRollingMax(type, 30);
// sleep to get to a new bucket
time.Increment(counter._bucketSizeInMillseconds);
counter.UpdateRollingMax(type, 40);
// sleep to get to a new bucket
time.Increment(counter._bucketSizeInMillseconds);
counter.UpdateRollingMax(type, 15);
Assert.Equal(40, counter.GetRollingMaxValue(type));
}
catch (Exception e)
{
output.WriteLine(e.ToString());
Assert.True(false, "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_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_IncrementInSingleBucket()
{
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);
// we should have 1 bucket
Assert.AreEqual(1, counter.Buckets.Size);
// the count should be 4
Assert.AreEqual(4, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Success).Sum());
Assert.AreEqual(2, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Failure).Sum());
Assert.AreEqual(1, counter.Buckets.GetLast().GetAdder(HystrixRollingNumberEvent.Timeout).Sum());
}
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_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);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HystrixThreadPoolMetrics"/> class.
/// </summary>
/// <param name="threadPoolKey">The key of the parent thread pool.</param>
/// <param name="threadPool">The <see cref="ThreadPoolExecutor"/> of the parent thread pool.</param>
/// <param name="properties">The properties of the parent thread pool.</param>
private HystrixThreadPoolMetrics(HystrixThreadPoolKey threadPoolKey, ThreadPoolExecutor threadPool, IHystrixThreadPoolProperties properties)
{
this.threadPoolKey = threadPoolKey;
this.threadPool = threadPool;
this.properties = properties;
this.counter = new HystrixRollingNumber(properties.MetricsRollingStatisticalWindowInMilliseconds, properties.MetricsRollingStatisticalWindowBuckets);
}
public void TestEmptyBucketsFillIn()
{
var time = new MockedTime();
try
{
var counter = new HystrixRollingNumber(time, 200, 10);
// add 1
counter.Increment(HystrixRollingNumberEvent.SUCCESS);
// we should have 1 bucket
Assert.Equal(1, counter._buckets.Size);
// wait past 3 bucket time periods (the 1st bucket then 2 empty ones)
time.Increment(counter._bucketSizeInMillseconds * 3);
// add another
counter.Increment(HystrixRollingNumberEvent.SUCCESS);
// we should have 4 (1 + 2 empty + 1 new one) buckets
Assert.Equal(4, counter._buckets.Size);
}
catch (Exception e)
{
output.WriteLine(e.ToString());
Assert.True(false, "Exception: " + e.Message);
}
}
public void TestResetBuckets()
{
var time = new MockedTime();
try
{
var counter = new HystrixRollingNumber(time, 200, 10);
// we start out with 0 buckets in the queue
Assert.Equal(0, counter._buckets.Size);
// add 1
counter.Increment(HystrixRollingNumberEvent.SUCCESS);
// confirm we have 1 bucket
Assert.Equal(1, counter._buckets.Size);
// confirm we still have 1 bucket
Assert.Equal(1, counter._buckets.Size);
// add 1
counter.Increment(HystrixRollingNumberEvent.SUCCESS);
// we should now have a single bucket with no values in it instead of 2 or more buckets
Assert.Equal(1, counter._buckets.Size);
}
catch (Exception e)
{
output.WriteLine(e.ToString());
Assert.True(false, "Exception: " + e.Message);
}
}
public void TestRolling()
{
var time = new MockedTime();
var type = HystrixRollingNumberEvent.THREAD_MAX_ACTIVE;
var counter = new HystrixRollingNumber(time, 20, 2);
// iterate over 20 buckets on a queue sized for 2
for (var i = 0; i < 20; i++)
{
// first bucket
counter.GetCurrentBucket();
try
{
time.Increment(counter._bucketSizeInMillseconds);
}
catch (Exception)
{
// ignore
}
Assert.Equal(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);
}
}
internal HystrixCommandMetrics(string opName, string serviceName, string fullServiceName, string metricPrefix, IHystrixCommandProperties properties)
{
this.serviceName = serviceName;
this.opName = opName;
this.properties = properties;
this.fullServiceName = fullServiceName;
this.counter = new HystrixRollingNumber(properties.MetricsRollingStatisticalWindowInMilliseconds, properties.MetricsRollingStatisticalWindowBuckets);
this.successCounter = new LongAdder();
this.frameworkErrorCounter = new LongAdder();
this.validationErrorCounter = new LongAdder();
this.serviceErrorCounter = new LongAdder();
this.shortCircuitCounter = new LongAdder();
this.threadPoolRejectedCounter = new LongAdder();
this.timeoutCounter = new LongAdder();
int timeWindowInSeconds = properties.MetricsIntegerBufferTimeWindowInSeconds.Get();
int bucketTimeWindowInSeconds = properties.MetricsIntegerBufferBucketTimeWindowInSeconds.Get();
int bucketSizeLimit = properties.MetricsIntegerBufferBucketSizeLimit.Get();
this.executionOperationLatencyBuffer = new HystrixIntegerCircularBuffer(timeWindowInSeconds, bucketTimeWindowInSeconds, bucketSizeLimit);
this.requestLatencyBuffer = new HystrixIntegerCircularBuffer(timeWindowInSeconds, bucketTimeWindowInSeconds, bucketSizeLimit);
MetricNameEventDistribution = metricPrefix + ".event.distribution";
MetricNameConcurrentExecutionCount = metricPrefix + ".execution.concurrency";
MetricNameRequestCount = metricPrefix + ".request.count";
MetricNameLatency = metricPrefix + ".request.latency";
MetricNameLatencyDistribution = metricPrefix + ".request.latency.distribution";
MetricNameLatencyPercentile = metricPrefix + ".request.latency.percentile";
}
public void TestEmptyMax()
{
var time = new MockedTime();
var type = HystrixRollingNumberEvent.THREAD_MAX_ACTIVE;
var counter = new HystrixRollingNumber(time, 200, 10);
Assert.Equal(0, counter.GetRollingMaxValue(type));
}
public void RollingNumber_EmptyLatestValue()
{
MockedTime time = new MockedTime();
HystrixRollingNumberEvent type = HystrixRollingNumberEvent.ThreadMaxActive;
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
Assert.AreEqual(0, counter.GetValueOfLatestBucket(type));
}
public void TestEmptyLatestValue()
{
MockedTime time = new MockedTime();
HystrixRollingNumberEvent type = HystrixRollingNumberEvent.THREAD_MAX_ACTIVE;
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
Assert.Equal(0, counter.GetValueOfLatestBucket(type));
}
public void RollingNumber_EmptySum()
{
MockedTime time = new MockedTime();
HystrixRollingNumberEvent type = HystrixRollingNumberEvent.Collapsed;
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
Assert.AreEqual(0, counter.GetRollingSum(type));
}
public void TestEmptySum()
{
MockedTime time = new MockedTime();
HystrixRollingNumberEvent type = HystrixRollingNumberEvent.COLLAPSED;
HystrixRollingNumber counter = new HystrixRollingNumber(time, 200, 10);
Assert.Equal(0, counter.GetRollingSum(type));
}
public void Returns_Zero_If_No_Values_Have_Been_Added_Yet_For_Specific_Counter()
{
var rollingNumber = new HystrixRollingNumber(10000, 10);
// Act
long valueOfLatestBucket = rollingNumber.GetValueOfLatestBucket(HystrixRollingNumberEvent.Success);
Assert.Equal(0L, valueOfLatestBucket);
}
public void NotImplemented()
{
var rollingNumber = new HystrixRollingNumber(10000, 10);
// Act
long cumulativeSum = rollingNumber.GetCumulativeSum(HystrixRollingNumberEvent.Success);
Assert.Equal(0L, cumulativeSum);
}
public void NotImplemented()
{
var rollingNumber = new HystrixRollingNumber(10000, 10);
// Act
long value = rollingNumber.GetRollingSum(HystrixRollingNumberEvent.Success);
Assert.Equal(0, value);
}
public void Returns_Values_For_All_Buckets()
{
var rollingNumber = new HystrixRollingNumber(10000, 10);
// Act
long[] values = rollingNumber.GetValues(HystrixRollingNumberEvent.Success);
Assert.Equal(1, values.Length);
}
public void Returns_Zero_If_No_Values_Have_Been_Recorded()
{
var rollingNumber = new HystrixRollingNumber(10000, 10);
// Act
long rollingMaxValue = rollingNumber.GetRollingMaxValue(HystrixRollingNumberEvent.Success);
Assert.Equal(0L, rollingMaxValue);
}
public void Calculates_BucketSizeInMillseconds_From_TimeInMilliseconds_Divided_By_NumberOfBuckets()
{
var timeInMilliseconds = 10000;
var numberOfBuckets = 10;
// Act
var rollingNumber = new HystrixRollingNumber(timeInMilliseconds, numberOfBuckets);
Assert.Equal(1000, rollingNumber.BucketSizeInMillseconds);
}
public void Returns_Values_For_All_Buckets()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var rollingNumber = new HystrixRollingNumber(dateTimeProvider.Object, 10000, 10);
// Act
long[] values = rollingNumber.GetValues(HystrixRollingNumberEvent.Success);
Assert.Equal(1, values.Length);
}
public void Returns_Zero_If_No_Values_Have_Been_Recorded()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var rollingNumber = new HystrixRollingNumber(dateTimeProvider.Object, 10000, 10);
// Act
long rollingMaxValue = rollingNumber.GetRollingMaxValue(HystrixRollingNumberEvent.Success);
Assert.Equal(0L, rollingMaxValue);
}
internal HystrixCommandMetrics(HystrixCommandKey key, HystrixCommandGroupKey commandGroup, IHystrixCommandProperties properties, IHystrixEventNotifier eventNotifier)
{
this.key = key;
this.group = commandGroup;
this.properties = properties;
this.counter = new HystrixRollingNumber(properties.MetricsRollingStatisticalWindowInMilliseconds, properties.MetricsRollingStatisticalWindowBuckets);
this.percentileExecution = new HystrixRollingPercentile(properties.MetricsRollingPercentileWindowInMilliseconds, properties.MetricsRollingPercentileWindowBuckets, properties.MetricsRollingPercentileBucketSize, properties.MetricsRollingPercentileEnabled);
this.percentileTotal = new HystrixRollingPercentile(properties.MetricsRollingPercentileWindowInMilliseconds, properties.MetricsRollingPercentileWindowBuckets, properties.MetricsRollingPercentileBucketSize, properties.MetricsRollingPercentileEnabled);
this.eventNotifier = eventNotifier;
}
public void NotImplemented()
{
var dateTimeProvider = new Mock <IDateTimeProvider>();
var rollingNumber = new HystrixRollingNumber(dateTimeProvider.Object, 10000, 10);
// Act
long value = rollingNumber.GetRollingSum(HystrixRollingNumberEvent.Success);
Assert.Equal(0, value);
}
