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 long GetCumulativeSum(HystrixRollingNumberEvent type) { // this isn't 100% atomic since multiple threads can be affecting latestBucket & cumulativeSum independently // but that's okay since the count is always a moving target and we're accepting a "point in time" best attempt // we are however putting 'getValueOfLatestBucket' first since it can have side-affects on cumulativeSum whereas the inverse is not true return(GetValueOfLatestBucket(type) + _cumulativeSum.Get(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_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_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_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 static bool IsCounter(HystrixRollingNumberEvent @event) { switch (@event) { case HystrixRollingNumberEvent.SUCCESS: case HystrixRollingNumberEvent.FAILURE: case HystrixRollingNumberEvent.TIMEOUT: case HystrixRollingNumberEvent.SHORT_CIRCUITED: case HystrixRollingNumberEvent.THREAD_POOL_REJECTED: case HystrixRollingNumberEvent.SEMAPHORE_REJECTED: case HystrixRollingNumberEvent.BAD_REQUEST: case HystrixRollingNumberEvent.FALLBACK_SUCCESS: case HystrixRollingNumberEvent.FALLBACK_FAILURE: case HystrixRollingNumberEvent.FALLBACK_REJECTION: case HystrixRollingNumberEvent.FALLBACK_MISSING: case HystrixRollingNumberEvent.EXCEPTION_THROWN: case HystrixRollingNumberEvent.EMIT: case HystrixRollingNumberEvent.FALLBACK_EMIT: case HystrixRollingNumberEvent.THREAD_EXECUTION: case HystrixRollingNumberEvent.COLLAPSED: case HystrixRollingNumberEvent.RESPONSE_FROM_CACHE: case HystrixRollingNumberEvent.COLLAPSER_REQUEST_BATCHED: case HystrixRollingNumberEvent.COLLAPSER_BATCH: return(true); default: return(false); } }
public long[] GetValues(HystrixRollingNumberEvent type) { Bucket lastBucket = GetCurrentBucket(); if (lastBucket == null) { return(new long[0]); } // get buckets as an array (which is a copy of the current state at this point in time) Bucket[] bucketArray = _buckets.Array; // we have bucket data so we'll return an array of values for all buckets long[] values = new long[bucketArray.Length]; int i = 0; foreach (Bucket bucket in bucketArray) { if (HystrixRollingNumberEventHelper.IsCounter(type)) { values[i++] = bucket.GetAdder(type).Sum(); } else if (HystrixRollingNumberEventHelper.IsMaxUpdater(type)) { values[i++] = bucket.GetMaxUpdater(type).Max; } } return(values); }
public LongAdder GetAdder(HystrixRollingNumberEvent type) { if (!HystrixRollingNumberEventHelper.IsCounter(type)) { throw new InvalidOperationException("Type is not a Counter: " + type.ToString()); } return(adderForCounterType[(int)type]); }
public LongMaxUpdater GetMaxUpdater(HystrixRollingNumberEvent type) { if (!type.IsMaxUpdater()) { throw new InvalidOperationException("Type is not a MaxUpdater: " + type); } return(updaterForCounterType[(int)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)); }
private static bool HasAttribute <T>(HystrixRollingNumberEvent hystrixRollingNumberEvent) { var type = typeof(HystrixRollingNumberEvent); var memInfo = type.GetMember(hystrixRollingNumberEvent.ToString()); var attributes = memInfo[0].GetCustomAttributes(typeof(T), false); return(attributes.Length > 0); }
public static ThreadPoolEventType From(this HystrixRollingNumberEvent @event) { return(@event switch { HystrixRollingNumberEvent.THREAD_EXECUTION => ThreadPoolEventType.EXECUTED, HystrixRollingNumberEvent.THREAD_POOL_REJECTED => ThreadPoolEventType.REJECTED, _ => throw new ArgumentOutOfRangeException("Not an event that can be converted to HystrixEventType.ThreadPool : " + @event), });
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 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 LongMaxUpdater GetMaxUpdater(HystrixRollingNumberEvent type) { if (!HystrixRollingNumberEventHelper.IsMaxUpdater(type)) { throw new InvalidOperationException("Type is not a MaxUpdater: " + type.ToString()); } return _updaterForCounterType[(int)type]; }
public static CollapserEventType From(this HystrixRollingNumberEvent @event) { return(@event switch { HystrixRollingNumberEvent.COLLAPSER_BATCH => CollapserEventType.BATCH_EXECUTED, HystrixRollingNumberEvent.COLLAPSER_REQUEST_BATCHED => CollapserEventType.ADDED_TO_BATCH, HystrixRollingNumberEvent.RESPONSE_FROM_CACHE => CollapserEventType.RESPONSE_FROM_CACHE, _ => throw new ArgumentOutOfRangeException("Not an event that can be converted to HystrixEventType.Collapser : " + @event), });
/// <summary> /// Gets the <see cref="LongMaxUpdater"/> instance for the specified event. /// </summary> /// <param name="type">The specified event.</param> /// <returns>The <see cref="LongMaxUpdater"/> instance for the specified event.</returns> public LongMaxUpdater GetMaxUpdater(HystrixRollingNumberEvent type) { if (!type.IsMaxUpdater()) { throw new ArgumentException(string.Format("Type is not a MaxUpdater: {0}", type), "type"); } return(this.updaterForCounterType[(int)type]); }
public static HystrixEventType From(this HystrixRollingNumberEvent @event) { switch (@event) { case HystrixRollingNumberEvent.EMIT: return(HystrixEventType.EMIT); case HystrixRollingNumberEvent.SUCCESS: return(HystrixEventType.SUCCESS); case HystrixRollingNumberEvent.FAILURE: return(HystrixEventType.FAILURE); case HystrixRollingNumberEvent.TIMEOUT: return(HystrixEventType.TIMEOUT); case HystrixRollingNumberEvent.SHORT_CIRCUITED: return(HystrixEventType.SHORT_CIRCUITED); case HystrixRollingNumberEvent.THREAD_POOL_REJECTED: return(HystrixEventType.THREAD_POOL_REJECTED); case HystrixRollingNumberEvent.SEMAPHORE_REJECTED: return(HystrixEventType.SEMAPHORE_REJECTED); case HystrixRollingNumberEvent.FALLBACK_EMIT: return(HystrixEventType.FALLBACK_EMIT); case HystrixRollingNumberEvent.FALLBACK_SUCCESS: return(HystrixEventType.FALLBACK_SUCCESS); case HystrixRollingNumberEvent.FALLBACK_FAILURE: return(HystrixEventType.FALLBACK_FAILURE); case HystrixRollingNumberEvent.FALLBACK_REJECTION: return(HystrixEventType.FALLBACK_REJECTION); case HystrixRollingNumberEvent.FALLBACK_MISSING: return(HystrixEventType.FALLBACK_MISSING); case HystrixRollingNumberEvent.EXCEPTION_THROWN: return(HystrixEventType.EXCEPTION_THROWN); case HystrixRollingNumberEvent.RESPONSE_FROM_CACHE: return(HystrixEventType.RESPONSE_FROM_CACHE); case HystrixRollingNumberEvent.COLLAPSED: return(HystrixEventType.COLLAPSED); case HystrixRollingNumberEvent.BAD_REQUEST: return(HystrixEventType.BAD_REQUEST); default: throw new ArgumentOutOfRangeException("Not an event that can be converted to HystrixEventType : " + @event); } }
public long GetRollingMaxValue(HystrixRollingNumberEvent type) { long[] values = GetValues(type); if (values.Length == 0) { return(0); } Array.Sort(values); return(values[values.Length - 1]); }
/** * Get the value of the latest (current) bucket in the rolling counter for the given {@link HystrixRollingNumberEvent} type. * <p> * The {@link HystrixRollingNumberEvent} must be a "counter" type <code>HystrixRollingNumberEvent.isCounter() == true</code>. * * @param type * HystrixRollingNumberEvent defining which counter to retrieve value from * @return * value from latest bucket for given {@link HystrixRollingNumberEvent} counter type */ public long GetValueOfLatestBucket(HystrixRollingNumberEvent type) { Bucket lastBucket = GetCurrentBucket(); if (lastBucket == null) { return(0); } // we have bucket data so we'll return the lastBucket return(lastBucket.Get(type)); }
public static bool IsMaxUpdater(HystrixRollingNumberEvent @event) { switch (@event) { case HystrixRollingNumberEvent.COMMAND_MAX_ACTIVE: case HystrixRollingNumberEvent.THREAD_MAX_ACTIVE: return(true); default: return(false); } }
public long Get(HystrixRollingNumberEvent type) { if (HystrixRollingNumberEventHelper.IsCounter(type)) { return(adderForCounterType[(int)type].Sum()); } if (HystrixRollingNumberEventHelper.IsMaxUpdater(type)) { return(updaterForCounterType[(int)type].Max); } throw new InvalidOperationException("Unknown type of event: " + type.ToString()); }
public long Get(HystrixRollingNumberEvent type) { if (type.IsCounter()) { return(adderForCounterType[(int)type].GetValue()); } if (type.IsMaxUpdater()) { return(updaterForCounterType[(int)type].Max()); } throw new InvalidOperationException("Unknown type of event: " + type); }
public static ThreadPoolEventType From(this HystrixRollingNumberEvent @event) { switch (@event) { case HystrixRollingNumberEvent.THREAD_EXECUTION: return(ThreadPoolEventType.EXECUTED); case HystrixRollingNumberEvent.THREAD_POOL_REJECTED: return(ThreadPoolEventType.REJECTED); default: throw new ArgumentOutOfRangeException("Not an event that can be converted to HystrixEventType.ThreadPool : " + @event); } }
public void Throws_InvalidOperationException_For_All_Hystrix_RollingNumberEvent_Items_That_Are_Not_MaxUpdaters() { var bucket = new RollingNumberBucket(DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond); var enumValues = Enum.GetValues(typeof(HystrixRollingNumberEvent)).Cast <HystrixRollingNumberEvent>(); foreach (var enumValue in enumValues) { if (!enumValue.IsMaxUpdater()) { HystrixRollingNumberEvent value = enumValue; Assert.Throws <InvalidOperationException>(() => bucket.GetMaxUpdater(value)); } } }
/// <summary> /// Gets the value for the specified <see cref="HystrixRollingNumberEvent"/> in this bucket. /// (Returns <see cref="LongAdder.Sum()"/> for Counter types and <see cref="LongMaxUpdater.Max()"/> for MaxUpdater types.) /// </summary> /// <param name="type">The specified event.</param> /// <returns>The value for the specified event in this bucket.</returns> public long Get(HystrixRollingNumberEvent type) { if (type.IsCounter()) { return(this.adderForCounterType[(int)type].Sum()); } if (type.IsMaxUpdater()) { return(this.updaterForCounterType[(int)type].Max()); } throw new ArgumentException(string.Format("Unknown type of event: {0}", type), "type"); }
/// <summary> /// Get the sum of all buckets in the rolling counter for the given <see cref="HystrixRollingNumberEvent"/> type. /// The <see cref="HystrixRollingNumberEvent"/> must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true). /// </summary> /// <param name="type">defining which counter to retrieve values from</param> /// <returns>Value from the given <see cref="HystrixRollingNumberEvent"/> counter type.</returns> public long GetRollingSum(HystrixRollingNumberEvent type) { if (this.GetCurrentBucket() == null) { return(0); } long sum = 0; foreach (Bucket b in this.buckets) { sum += b.GetAdder(type).Sum(); } return(sum); }
public static CollapserEventType From(this HystrixRollingNumberEvent @event) { switch (@event) { case HystrixRollingNumberEvent.COLLAPSER_BATCH: return(CollapserEventType.BATCH_EXECUTED); case HystrixRollingNumberEvent.COLLAPSER_REQUEST_BATCHED: return(CollapserEventType.ADDED_TO_BATCH); case HystrixRollingNumberEvent.RESPONSE_FROM_CACHE: return(CollapserEventType.RESPONSE_FROM_CACHE); default: throw new ArgumentOutOfRangeException("Not an event that can be converted to HystrixEventType.Collapser : " + @event); } }
/// <summary> /// Get the sum of all buckets in the rolling counter for the given <see cref="HystrixRollingNumberEvent"/> type. /// The <see cref="HystrixRollingNumberEvent"/> must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true). /// </summary> /// <param name="type">defining which counter to retrieve values from</param> /// <returns>Value from the given <see cref="HystrixRollingNumberEvent"/> counter type.</returns> public long GetRollingSum(HystrixRollingNumberEvent type) { if (this.GetCurrentBucket() == null) { return 0; } long sum = 0; foreach (Bucket b in this.buckets) { sum += b.GetAdder(type).Sum(); } return sum; }
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); } }
/// <summary> /// Get the value of the latest (current) bucket in the rolling counter for the given <see cref="HystrixRollingNumberEvent"/> type. /// The <see cref="HystrixRollingNumberEvent"/> must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true). /// </summary> /// <param name="type">HystrixRollingNumberEvent defining which counter to retrieve value from</param> /// <returns>value from latest bucket for given <see cref="HystrixRollingNumberEvent"/> counter type</returns> public long GetValueOfLatestBucket(HystrixRollingNumberEvent type) { Bucket lastBucket = this.GetCurrentBucket(); if (lastBucket == null) { return 0; } // we have bucket data so we'll return the lastBucket return lastBucket.Get(type); }
/// <summary> /// Get an array of values for all buckets in the rolling counter for the given <see cref="HystrixRollingNumberEvent"/> type. /// Index 0 is the oldest bucket. /// The <see cref="HystrixRollingNumberEvent"/> must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true). /// </summary> /// <param name="type">HystrixRollingNumberEvent defining which counter to retrieve values from</param> /// <returns>Array of values from each of the rolling buckets for given <see cref="HystrixRollingNumberEvent"/> counter type</returns> public long[] GetValues(HystrixRollingNumberEvent type) { if (this.GetCurrentBucket() == null) { return new long[0]; } // get buckets as an array (which is a copy of the current state at this point in time) Bucket[] bucketArray = this.buckets.GetArray(); // we have bucket data so we'll return an array of values for all buckets long[] values = new long[bucketArray.Length]; int i = 0; foreach (Bucket bucket in bucketArray) { if (type.IsCounter()) { values[i++] = bucket.GetAdder(type).Sum(); } else if (type.IsMaxUpdater()) { values[i++] = bucket.GetMaxUpdater(type).Max(); } } return values; }
/// <summary> /// Get the max value of values in all buckets for the given <see cref="HystrixRollingNumberEvent"/> type. /// The <see cref="HystrixRollingNumberEvent"/> must be a "MaxUpdater" type (HystrixRollingNumberEvent.IsMaxUpdater() == true). /// </summary> /// <param name="type">HystrixRollingNumberEvent defining which "MaxUpdater" to retrieve values from</param> /// <returns>Max value for given <see cref="HystrixRollingNumberEvent"/> type during rolling window</returns> public long GetRollingMaxValue(HystrixRollingNumberEvent type) { long[] values = this.GetValues(type); if (values.Length == 0) { return 0; } else { Array.Sort(values); return values[values.Length - 1]; } }
/// <summary> /// Gets the cumulative value for the specified <see cref="HystrixRollingNumberEvent"/>. /// (Returns <see cref="LongAdder.Sum()"/> for Counter types and <see cref="LongMaxUpdater.Max()"/> for MaxUpdater types.) /// </summary> /// <param name="type">The specified event.</param> /// <returns>The cumulative value for the specified event.</returns> public long Get(HystrixRollingNumberEvent type) { if (type.IsCounter()) { return this.adderForCounterType[(int)type].Sum(); } else if (type.IsMaxUpdater()) { return this.updaterForCounterType[(int)type].Max(); } else { throw new ArgumentException(string.Format("Unknown type of event: {0}", type), "type"); } }
/// <summary> /// Get the cumulative sum of all buckets ever since the application started without rolling for the given /// <see cref="HystrixRollingNumberEvent"/> type. See <see cref="GetRollingSum(HystrixRollingNumberEvent)"/> for the rolling sum. /// </summary> /// <param name="type">Must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true).</param> /// <returns>Cumulative sum of all increments and adds for the given <see cref="HystrixRollingNumberEvent"/> counter type.</returns> public long GetCumulativeSum(HystrixRollingNumberEvent type) { // This isn't 100% atomic since multiple threads can be affecting latestBucket & cumulativeSum independently // but that's okay since the count is always a moving target and we're accepting a "point in time" best attempt // we are however putting 'GetValueOfLatestBucket' first since it can have side-affects on cumulativeSum whereas the inverse is not true return this.GetValueOfLatestBucket(type) + this.cumulativeSum.Get(type); }
/// <summary> /// Add to the counter in the current bucket for the given <see cref="HystrixRollingNumberEvent"/> type. /// </summary> /// <param name="type">Defining which counter to add to, must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true).</param> /// <param name="value">Value to be added to the current bucket.</param> public void Add(HystrixRollingNumberEvent type, long value) { this.GetCurrentBucket().GetAdder(type).Add(value); }
/// <summary> /// Gets the <see cref="LongMaxUpdater"/> instance for the specified event. /// </summary> /// <param name="type">The specified event.</param> /// <returns>The <see cref="LongMaxUpdater"/> instance for the specified event.</returns> public LongMaxUpdater GetMaxUpdater(HystrixRollingNumberEvent type) { if (!type.IsMaxUpdater()) { throw new ArgumentException(string.Format("Type is not a MaxUpdater: {0}", type), "type"); } return this.updaterForCounterType[(int)type]; }
/// <summary> /// Increment the counter in the current bucket by one for the given <see cref="HystrixRollingNumberEvent"/> type. /// </summary> /// <param name="type">Defining which counter to increment, must be a "Counter" type (HystrixRollingNumberEvent.IsCounter() == true).</param> public void Increment(HystrixRollingNumberEvent type) { this.GetCurrentBucket().GetAdder(type).Increment(); }
/// <summary> /// Update a value and retain the max value. /// </summary> /// <param name="type">Defining which counter to update, must be a "MaxUpdater" type (HystrixRollingNumberEvent.IsMaxUpdater() == true).</param> /// <param name="value">Value to be updated to the current bucket</param> public void UpdateRollingMax(HystrixRollingNumberEvent type, long value) { this.GetCurrentBucket().GetMaxUpdater(type).Update(value); }