Fix spelling of Reservior (#237)

jon-armen · jon-armen · commit 14ce4c1d5916 · 2022-04-15T02:14:03.000-04:00
Co-authored-by: Jon Armen &lt;jarmen@bstglobal.com&gt;
diff --git a/sdk/src/Core/Sampling/DefaultSamplingStrategy.cs b/sdk/src/Core/Sampling/DefaultSamplingStrategy.cs
@@ -127,17 +127,17 @@ public SamplingResponse ShouldTrace(SamplingInput input)
         private SamplingResponse ProcessMatchedRule(SamplingRule sampleRule, TimeStamp time)
         {
             bool shouldSample = true;
-            Reservior reservior = sampleRule.Reservior;
+            Reservoir reservoir = sampleRule.Reservoir;
             SamplingResponse sampleResult = null;
 
             sampleRule.IncrementRequestCount(); // increment request counter for matched rule
-            ReserviorDecision reserviorDecision = reservior.BorrowOrTake(time, sampleRule.CanBorrow); // check if we can borrow or take from reservior
+            ReservoirDecision reservoirDecision = reservoir.BorrowOrTake(time, sampleRule.CanBorrow); // check if we can borrow or take from reservoir
 
-            if (reserviorDecision == ReserviorDecision.Borrow)
+            if (reservoirDecision == ReservoirDecision.Borrow)
             {
                 sampleRule.IncrementBorrowCount();
             }
-            else if (reserviorDecision == ReserviorDecision.Take)
+            else if (reservoirDecision == ReservoirDecision.Take)
             {
                 sampleRule.IncrementSampledCount();
             }
diff --git a/sdk/src/Core/Sampling/Reservoir.cs b/sdk/src/Core/Sampling/Reservoir.cs
@@ -1,5 +1,5 @@
 ﻿//-----------------------------------------------------------------------------
-// <copyright file="Reservior.cs" company="Amazon.com">
+// <copyright file="Reservoir.cs" company="Amazon.com">
 //      Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 //
 //      Licensed under the Apache License, Version 2.0 (the "License").
@@ -20,23 +20,23 @@
 namespace Amazon.XRay.Recorder.Core.Sampling
 {
     /// <summary>
-    /// Thread safe reservior which holds fixed sampling quota, borrowed count and TTL.
+    /// Thread safe reservoir which holds fixed sampling quota, borrowed count and TTL.
     /// </summary>
-    public class Reservior
+    public class Reservoir
     {
         private TimeStamp _thisSec = new TimeStamp();
         private TimeStamp _refereshedAt = new TimeStamp();
         private int _takenThisSec;
         private int _borrowedThisSec;
         private readonly int _defaultInterval = 10; // 10 seconds
         private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
-        private static readonly Logger _logger = Logger.GetLogger(typeof(Reservior));
+        private static readonly Logger _logger = Logger.GetLogger(typeof(Reservoir));
 
         public TimeStamp TTL { get; set; }
         public int? Quota { get; set; }
         public int? Interval { get; set; }
 
-        internal Reservior()
+        internal Reservoir()
         {
             Quota = null;
             TTL = null;
@@ -45,12 +45,12 @@ internal Reservior()
         }
 
         /// <summary>
-        /// If quota is valid, <see cref="ReserviorDecision"/> is either take or no else 1 request/sec is borrowed.
+        /// If quota is valid, <see cref="ReservoirDecision"/> is either take or no else 1 request/sec is borrowed.
         /// </summary>
         /// <param name="current"> Current timestamp.</param>
         /// <param name="canBorrow">If true, and quota not valid, single request is borrowed in the current sec for the given <see cref="SamplingRule"/>.</param>
-        /// <returns>The reservior decision.</returns>
-        internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)
+        /// <returns>The reservoir decision.</returns>
+        internal ReservoirDecision BorrowOrTake(TimeStamp current, bool canBorrow)
         {
             _lock.EnterWriteLock();
             try
@@ -61,23 +61,23 @@ internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)
                 {
                     if(_takenThisSec >= Quota)
                     {
-                        return ReserviorDecision.No;
+                        return ReservoirDecision.No;
                     }
                     _takenThisSec += 1;
-                    return ReserviorDecision.Take;
+                    return ReservoirDecision.Take;
                 }
 
                 if (canBorrow) // Otherwise try to borrow if the quota is not present or expired.
                 {
                     if(_borrowedThisSec >= 1)
                     {
-                        return ReserviorDecision.No;
+                        return ReservoirDecision.No;
                     }
                     _borrowedThisSec += 1;
-                    return ReserviorDecision.Borrow;
+                    return ReservoirDecision.Borrow;
                 }
 
-                return ReserviorDecision.No;
+                return ReservoirDecision.No;
             }
             finally
             {
@@ -96,7 +96,7 @@ internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)
         }
 
         /// <summary>
-        /// Load quota, ttl and interval into current reservior.
+        /// Load quota, ttl and interval into current reservoir.
         /// </summary>
         /// <param name="t">Instance of <see cref="Target"/>.</param>
         /// <param name="now">Current timestamp.</param>
@@ -105,9 +105,9 @@ internal void LoadQuota(Target t, TimeStamp now)
             _lock.EnterWriteLock();
             try
             {
-                if (t.ReserviorQuota != null)
+                if (t.ReservoirQuota != null)
                 {
-                    Quota = t.ReserviorQuota;
+                    Quota = t.ReservoirQuota;
                 }
 
                 if (t.TTL != null)
@@ -140,7 +140,7 @@ internal bool ShouldReport(TimeStamp now)
             }
         }
 
-        internal void CopyFrom(Reservior r)
+        internal void CopyFrom(Reservoir r)
         {
             _lock.EnterWriteLock();
             try
diff --git a/sdk/src/Core/Sampling/ReservoirDecision.cs b/sdk/src/Core/Sampling/ReservoirDecision.cs
@@ -1,5 +1,5 @@
 ﻿//-----------------------------------------------------------------------------
-// <copyright file="ReserviorDecision.cs" company="Amazon.com">
+// <copyright file="ReservoirDecision.cs" company="Amazon.com">
 //      Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 //
 //      Licensed under the Apache License, Version 2.0 (the "License").
@@ -21,7 +21,7 @@ namespace Amazon.XRay.Recorder.Core.Sampling
     /// An Enum of decisions, the reservoir could make based on
     /// assigned quota with TTL and the current timestamp/usage.
     /// </summary>
-    public enum ReserviorDecision
+    public enum ReservoirDecision
     {
         Take = 't',
         Borrow = 'b',
diff --git a/sdk/src/Core/Sampling/RuleCache.cs b/sdk/src/Core/Sampling/RuleCache.cs
@@ -125,7 +125,7 @@ public void LoadTargets(IList<Target> targets)
                 {
                     if (_cache.TryGetValue(t.RuleName, out SamplingRule rule))
                     {
-                        rule.Reservior.LoadQuota(t, now);
+                        rule.Reservoir.LoadQuota(t, now);
                         rule.SetRate(t.FixedRate);
                     }
                 }
diff --git a/sdk/src/Core/Sampling/SamplingRule.cs b/sdk/src/Core/Sampling/SamplingRule.cs
@@ -32,7 +32,7 @@ public class SamplingRule : IComparable<SamplingRule>
         public string Host { get; set; }
         public string RuleName { get; set; }
         public int Priority { get; set; }
-        public Reservior Reservior { get; set; }
+        public Reservoir Reservoir { get; set; }
         public double Rate { get; private set; }
         public int ReservoirSize { get; private set; }
         public string HTTPMethod { get; set; }
@@ -63,7 +63,7 @@ public SamplingRule(string ruleName, int priority, double fixedRate, int reservo
             ServiceType = serviceType;
             ResourceARN = resourceARN;
             Attributes = attributes;
-            Reservior = new Reservior();
+            Reservoir = new Reservoir();
             Statistics = new Statistics();
         }
 
@@ -156,7 +156,7 @@ internal double GetRate()
 
         internal bool ShouldReport(TimeStamp now)
         {
-            if (EverMatched() && Reservior.ShouldReport(now))
+            if (EverMatched() && Reservoir.ShouldReport(now))
             {
                 return true;
             }
@@ -172,7 +172,7 @@ internal bool EverMatched()
         internal void Merge(SamplingRule oldRule)
         {
             Statistics.CopyFrom(oldRule.Statistics);
-            Reservior.CopyFrom(oldRule.Reservior);
+            Reservoir.CopyFrom(oldRule.Reservoir);
             oldRule = null;
         }
 
diff --git a/sdk/src/Core/Sampling/Target.cs b/sdk/src/Core/Sampling/Target.cs
@@ -29,9 +29,9 @@ public class Target
         public double FixedRate;
 
         /// <summary>
-        /// Reservior quota for the rule.
+        /// Reservoir quota for the rule.
         /// </summary>
-        public int? ReserviorQuota;
+        public int? ReservoirQuota;
 
         /// <summary>
         /// TTL for the rule.
@@ -51,7 +51,7 @@ public Target(string ruleName, double fixedRate, int? reservoirQuota, DateTime?
         {
             RuleName = ruleName;
             FixedRate = fixedRate;
-            ReserviorQuota = reservoirQuota;
+            ReservoirQuota = reservoirQuota;
             TTL = new TimeStamp(ttl);
             Interval = interval;
         }
diff --git a/sdk/test/UnitTests/RuleCacheTests.cs b/sdk/test/UnitTests/RuleCacheTests.cs
@@ -94,15 +94,15 @@ public void TestLoadRulesSort() // Test whether cache is sorted after LoadRules
 
             rulesInCache = ruleCache.GetRules(); // check targets value is copied
 
-            Reservior actualReservior2 = rulesInCache[0].Reservior;
-            Assert.AreEqual(currentTime.Time, actualReservior2.TTL.Time);
-            Assert.AreEqual(t2.Interval, actualReservior2.Interval);
-            Assert.AreEqual(t2.ReserviorQuota, actualReservior2.Quota);
+            Reservoir actualReservoir2 = rulesInCache[0].Reservoir;
+            Assert.AreEqual(currentTime.Time, actualReservoir2.TTL.Time);
+            Assert.AreEqual(t2.Interval, actualReservoir2.Interval);
+            Assert.AreEqual(t2.ReservoirQuota, actualReservoir2.Quota);
 
-            Reservior actualReservior1 = rulesInCache[1].Reservior;
-            Assert.AreEqual(currentTime.Time, actualReservior1.TTL.Time);
-            Assert.AreEqual(t1.Interval, actualReservior1.Interval);
-            Assert.AreEqual(t1.ReserviorQuota, actualReservior1.Quota);
+            Reservoir actualReservoir1 = rulesInCache[1].Reservoir;
+            Assert.AreEqual(currentTime.Time, actualReservoir1.TTL.Time);
+            Assert.AreEqual(t1.Interval, actualReservoir1.Interval);
+            Assert.AreEqual(t1.ReservoirQuota, actualReservoir1.Quota);
 
         }
 
@@ -150,10 +150,10 @@ public void TestLoadRulesSort() // Test whether cache is sorted after LoadRules
             Assert.AreEqual(1, rulesInCache.Count); // only one rule should be present and statefule info should be carried from old rule
             Assert.AreEqual(1, rulesInCache[0].Priority); // implies new rule is added to cache
 
-            Reservior actualReservior1 = rulesInCache[0].Reservior;
-            Assert.AreEqual(currentTime.Time, actualReservior1.TTL.Time);
-            Assert.AreEqual(t1.Interval, actualReservior1.Interval);
-            Assert.AreEqual(t1.ReserviorQuota, actualReservior1.Quota);
+            Reservoir actualReservoir1 = rulesInCache[0].Reservoir;
+            Assert.AreEqual(currentTime.Time, actualReservoir1.TTL.Time);
+            Assert.AreEqual(t1.Interval, actualReservoir1.Interval);
+            Assert.AreEqual(t1.ReservoirQuota, actualReservoir1.Quota);
 
             Statistics statistics = rulesInCache[0].Statistics;
             Assert.AreEqual(expectedStatistic.RequestCount, statistics.RequestCount);

Original file line number	Diff line number	Diff line change
`@@ -127,17 +127,17 @@ public SamplingResponse ShouldTrace(SamplingInput input)`
`127`	`127`	`private SamplingResponse ProcessMatchedRule(SamplingRule sampleRule, TimeStamp time)`
`128`	`128`	`{`
`129`	`129`	`bool shouldSample = true;`
`130`		`- Reservior reservior = sampleRule.Reservior;`
	`130`	`+ Reservoir reservoir = sampleRule.Reservoir;`
`131`	`131`	`SamplingResponse sampleResult = null;`
`132`	`132`
`133`	`133`	`sampleRule.IncrementRequestCount(); // increment request counter for matched rule`
`134`		`- ReserviorDecision reserviorDecision = reservior.BorrowOrTake(time, sampleRule.CanBorrow); // check if we can borrow or take from reservior`
	`134`	`+ ReservoirDecision reservoirDecision = reservoir.BorrowOrTake(time, sampleRule.CanBorrow); // check if we can borrow or take from reservoir`
`135`	`135`
`136`		`- if (reserviorDecision == ReserviorDecision.Borrow)`
	`136`	`+ if (reservoirDecision == ReservoirDecision.Borrow)`
`137`	`137`	`{`
`138`	`138`	`sampleRule.IncrementBorrowCount();`
`139`	`139`	`}`
`140`		`- else if (reserviorDecision == ReserviorDecision.Take)`
	`140`	`+ else if (reservoirDecision == ReservoirDecision.Take)`
`141`	`141`	`{`
`142`	`142`	`sampleRule.IncrementSampledCount();`
`143`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`//-----------------------------------------------------------------------------`
`2`		`-// <copyright file="Reservior.cs" company="Amazon.com">`
	`2`	`+// <copyright file="Reservoir.cs" company="Amazon.com">`
`3`	`3`	`// Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.`
`4`	`4`	`//`
`5`	`5`	`// Licensed under the Apache License, Version 2.0 (the "License").`
`@@ -20,23 +20,23 @@`
`20`	`20`	`namespace Amazon.XRay.Recorder.Core.Sampling`
`21`	`21`	`{`
`22`	`22`	`/// <summary>`
`23`		`- /// Thread safe reservior which holds fixed sampling quota, borrowed count and TTL.`
	`23`	`+ /// Thread safe reservoir which holds fixed sampling quota, borrowed count and TTL.`
`24`	`24`	`/// </summary>`
`25`		`- public class Reservior`
	`25`	`+ public class Reservoir`
`26`	`26`	`{`
`27`	`27`	`private TimeStamp _thisSec = new TimeStamp();`
`28`	`28`	`private TimeStamp _refereshedAt = new TimeStamp();`
`29`	`29`	`private int _takenThisSec;`
`30`	`30`	`private int _borrowedThisSec;`
`31`	`31`	`private readonly int _defaultInterval = 10; // 10 seconds`
`32`	`32`	`private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();`
`33`		`- private static readonly Logger _logger = Logger.GetLogger(typeof(Reservior));`
	`33`	`+ private static readonly Logger _logger = Logger.GetLogger(typeof(Reservoir));`
`34`	`34`
`35`	`35`	`public TimeStamp TTL { get; set; }`
`36`	`36`	`public int? Quota { get; set; }`
`37`	`37`	`public int? Interval { get; set; }`
`38`	`38`
`39`		`- internal Reservior()`
	`39`	`+ internal Reservoir()`
`40`	`40`	`{`
`41`	`41`	`Quota = null;`
`42`	`42`	`TTL = null;`
`@@ -45,12 +45,12 @@ internal Reservior()`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`/// <summary>`
`48`		`- /// If quota is valid, <see cref="ReserviorDecision"/> is either take or no else 1 request/sec is borrowed.`
	`48`	`+ /// If quota is valid, <see cref="ReservoirDecision"/> is either take or no else 1 request/sec is borrowed.`
`49`	`49`	`/// </summary>`
`50`	`50`	`/// <param name="current"> Current timestamp.</param>`
`51`	`51`	`/// <param name="canBorrow">If true, and quota not valid, single request is borrowed in the current sec for the given <see cref="SamplingRule"/>.</param>`
`52`		`- /// <returns>The reservior decision.</returns>`
`53`		`- internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)`
	`52`	`+ /// <returns>The reservoir decision.</returns>`
	`53`	`+ internal ReservoirDecision BorrowOrTake(TimeStamp current, bool canBorrow)`
`54`	`54`	`{`
`55`	`55`	`_lock.EnterWriteLock();`
`56`	`56`	`try`
`@@ -61,23 +61,23 @@ internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)`
`61`	`61`	`{`
`62`	`62`	`if(_takenThisSec >= Quota)`
`63`	`63`	`{`
`64`		`- return ReserviorDecision.No;`
	`64`	`+ return ReservoirDecision.No;`
`65`	`65`	`}`
`66`	`66`	`_takenThisSec += 1;`
`67`		`- return ReserviorDecision.Take;`
	`67`	`+ return ReservoirDecision.Take;`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`if (canBorrow) // Otherwise try to borrow if the quota is not present or expired.`
`71`	`71`	`{`
`72`	`72`	`if(_borrowedThisSec >= 1)`
`73`	`73`	`{`
`74`		`- return ReserviorDecision.No;`
	`74`	`+ return ReservoirDecision.No;`
`75`	`75`	`}`
`76`	`76`	`_borrowedThisSec += 1;`
`77`		`- return ReserviorDecision.Borrow;`
	`77`	`+ return ReservoirDecision.Borrow;`
`78`	`78`	`}`
`79`	`79`
`80`		`- return ReserviorDecision.No;`
	`80`	`+ return ReservoirDecision.No;`
`81`	`81`	`}`
`82`	`82`	`finally`
`83`	`83`	`{`
`@@ -96,7 +96,7 @@ internal ReserviorDecision BorrowOrTake(TimeStamp current, bool canBorrow)`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/// <summary>`
`99`		`- /// Load quota, ttl and interval into current reservior.`
	`99`	`+ /// Load quota, ttl and interval into current reservoir.`
`100`	`100`	`/// </summary>`
`101`	`101`	`/// <param name="t">Instance of <see cref="Target"/>.</param>`
`102`	`102`	`/// <param name="now">Current timestamp.</param>`
`@@ -105,9 +105,9 @@ internal void LoadQuota(Target t, TimeStamp now)`
`105`	`105`	`_lock.EnterWriteLock();`
`106`	`106`	`try`
`107`	`107`	`{`
`108`		`- if (t.ReserviorQuota != null)`
	`108`	`+ if (t.ReservoirQuota != null)`
`109`	`109`	`{`
`110`		`- Quota = t.ReserviorQuota;`
	`110`	`+ Quota = t.ReservoirQuota;`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`if (t.TTL != null)`
`@@ -140,7 +140,7 @@ internal bool ShouldReport(TimeStamp now)`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`		`- internal void CopyFrom(Reservior r)`
	`143`	`+ internal void CopyFrom(Reservoir r)`
`144`	`144`	`{`
`145`	`145`	`_lock.EnterWriteLock();`
`146`	`146`	`try`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ public void LoadTargets(IList<Target> targets)`
`125`	`125`	`{`
`126`	`126`	`if (_cache.TryGetValue(t.RuleName, out SamplingRule rule))`
`127`	`127`	`{`
`128`		`- rule.Reservior.LoadQuota(t, now);`
	`128`	`+ rule.Reservoir.LoadQuota(t, now);`
`129`	`129`	`rule.SetRate(t.FixedRate);`
`130`	`130`	`}`
`131`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public class SamplingRule : IComparable<SamplingRule>`
`32`	`32`	`public string Host { get; set; }`
`33`	`33`	`public string RuleName { get; set; }`
`34`	`34`	`public int Priority { get; set; }`
`35`		`- public Reservior Reservior { get; set; }`
	`35`	`+ public Reservoir Reservoir { get; set; }`
`36`	`36`	`public double Rate { get; private set; }`
`37`	`37`	`public int ReservoirSize { get; private set; }`
`38`	`38`	`public string HTTPMethod { get; set; }`
`@@ -63,7 +63,7 @@ public SamplingRule(string ruleName, int priority, double fixedRate, int reservo`
`63`	`63`	`ServiceType = serviceType;`
`64`	`64`	`ResourceARN = resourceARN;`
`65`	`65`	`Attributes = attributes;`
`66`		`- Reservior = new Reservior();`
	`66`	`+ Reservoir = new Reservoir();`
`67`	`67`	`Statistics = new Statistics();`
`68`	`68`	`}`
`69`	`69`
`@@ -156,7 +156,7 @@ internal double GetRate()`
`156`	`156`
`157`	`157`	`internal bool ShouldReport(TimeStamp now)`
`158`	`158`	`{`
`159`		`- if (EverMatched() && Reservior.ShouldReport(now))`
	`159`	`+ if (EverMatched() && Reservoir.ShouldReport(now))`
`160`	`160`	`{`
`161`	`161`	`return true;`
`162`	`162`	`}`
`@@ -172,7 +172,7 @@ internal bool EverMatched()`
`172`	`172`	`internal void Merge(SamplingRule oldRule)`
`173`	`173`	`{`
`174`	`174`	`Statistics.CopyFrom(oldRule.Statistics);`
`175`		`- Reservior.CopyFrom(oldRule.Reservior);`
	`175`	`+ Reservoir.CopyFrom(oldRule.Reservoir);`
`176`	`176`	`oldRule = null;`
`177`	`177`	`}`
`178`	`178`