def parse_sampling_strategy(response):
"""
Parse SamplingStrategyResponse and converts to a Sampler.
:param response:
:return: Returns Go-style (value, error) pair
"""
s_type = response.strategyType
if s_type == sampling_manager.SamplingStrategyType.PROBABILISTIC:
if response.probabilisticSampling is None:
return None, 'probabilisticSampling field is None'
sampling_rate = response.probabilisticSampling.samplingRate
if 0 <= sampling_rate <= 1.0:
from jaeger_client.sampler import ProbabilisticSampler
return ProbabilisticSampler(rate=sampling_rate), None
return None, ('Probabilistic sampling rate not in [0, 1] range: %s' %
sampling_rate)
elif s_type == sampling_manager.SamplingStrategyType.RATE_LIMITING:
if response.rateLimitingSampling is None:
return None, 'rateLimitingSampling field is None'
mtps = response.rateLimitingSampling.maxTracesPerSecond
if 0 <= mtps < 500:
from jaeger_client.sampler import RateLimitingSampler
return RateLimitingSampler(max_traces_per_second=mtps), None
return None, ('Rate limiting parameter not in [0, 500] range: %s' %
mtps)
return None, ('Unsupported sampling strategy type: %s' % s_type)
def test_sampler_equality():
const1 = ConstSampler(True)
const2 = ConstSampler(True)
const3 = ConstSampler(False)
assert const1 == const2
assert const1 != const3
prob1 = ProbabilisticSampler(rate=0.01)
prob2 = ProbabilisticSampler(rate=0.01)
prob3 = ProbabilisticSampler(rate=0.02)
assert prob1 == prob2
assert prob1 != prob3
assert const1 != prob1
rate1 = RateLimitingSampler(max_traces_per_second=0.01)
rate2 = RateLimitingSampler(max_traces_per_second=0.01)
rate3 = RateLimitingSampler(max_traces_per_second=0.02)
assert rate1 == rate2
assert rate1 != rate3
assert rate1 != const1
assert rate1 != prob1
def _update_rate_limiting_or_probabilistic_sampler(self, response):
s_type = response.get(STRATEGY_TYPE_STR)
if s_type == PROBABILISTIC_SAMPLING_STRATEGY:
sampling_rate = get_sampling_probability(response)
new_sampler = ProbabilisticSampler(rate=sampling_rate)
elif s_type == RATE_LIMITING_SAMPLING_STRATEGY:
mtps = get_rate_limit(response)
if 0 <= mtps < 500:
new_sampler = RateLimitingSampler(max_traces_per_second=mtps)
else:
raise ValueError(
'Rate limiting parameter not in [0, 500] range: %s' % mtps)
else:
raise ValueError('Unsupported sampling strategy type: %s' % s_type)
self._replace_sampler(new_sampler)
type('obj', (object,), {'body': {'decode': None}})()
sampler._sampling_request_callback(return_value)
assert error_reporter.error.call_count == 4
assert prev_sampler is sampler.sampler, 'error updating sampler should not update the sampler'
return_value.result = lambda *args: \
type('obj', (object,), {'body': probabilistic_strategy})()
sampler._sampling_request_callback(return_value)
assert '%s' % sampler.sampler == 'ProbabilisticSampler(0.002)', 'updating sampler from adaptive to probabilistic should work'
sampler.close()
probabilistic_sampler = ProbabilisticSampler(0.002)
other_probabilistic_sampler = ProbabilisticSampler(0.003)
rate_limiting_sampler = RateLimitingSampler(10)
other_rate_limiting_sampler = RateLimitingSampler(20)
@pytest.mark.parametrize("response,init_sampler,expected_sampler,err_count,err_msg,reference_equivalence,max_operations", [
(
{"strategyType":"PROBABILISTIC","probabilisticSampling":{"samplingRate":0.003}},
probabilistic_sampler,
other_probabilistic_sampler,
0,
'sampler should update to new probabilistic sampler',
False,
10,
),
(
{"strategyType":"PROBABILISTIC","probabilisticSampling":{"samplingRate":400}},
probabilistic_sampler,
def test_rate_limiting_sampler():
sampler = RateLimitingSampler(2)
sampler.rate_limiter.balance = 2.0
# stop time by overwriting timestamp() function to always return
# the same time
ts = time.time()
sampler.rate_limiter.last_tick = ts
with mock.patch('jaeger_client.rate_limiter.RateLimiter.timestamp') \
as mock_time:
mock_time.side_effect = lambda: ts # always return same time
assert sampler.rate_limiter.timestamp() == ts
sampled, _ = sampler.is_sampled(0)
assert sampled, 'initial balance allows first item'
sampled, _ = sampler.is_sampled(0)
assert sampled, 'initial balance allows second item'
sampled, _ = sampler.is_sampled(0)
assert not sampled, 'initial balance exhausted'
# move time 250ms forward, not enough credits to pay for one sample
mock_time.side_effect = lambda: ts + 0.25
sampled, _ = sampler.is_sampled(0)
assert not sampled, 'not enough time passed for full item'
# move time 500ms forward, now enough credits to pay for one sample
mock_time.side_effect = lambda: ts + 0.5
sampled, _ = sampler.is_sampled(0)
assert sampled, 'enough time for new item'
sampled, _ = sampler.is_sampled(0)
assert not sampled, 'no more balance'
# move time 5s forward, enough to accumulate credits for 10 samples,
# but it should still be capped at 2
sampler.last_tick = ts # reset the timer
mock_time.side_effect = lambda: ts + 5
sampled, _ = sampler.is_sampled(0)
assert sampled, 'enough time for new item'
sampled, _ = sampler.is_sampled(0)
assert sampled, 'enough time for second new item'
for i in range(0, 8):
sampled, tags = sampler.is_sampled(0)
assert not sampled, 'but no further, since time is stopped'
assert tags == get_tags('ratelimiting', 2)
sampler.close()
assert '%s' % sampler == 'RateLimitingSampler(2)'
# Test with rate limit of greater than 1 second
sampler = RateLimitingSampler(0.1)
sampler.rate_limiter.balance = 1.0
ts = time.time()
sampler.rate_limiter.last_tick = ts
with mock.patch('jaeger_client.rate_limiter.RateLimiter.timestamp') \
as mock_time:
mock_time.side_effect = lambda: ts # always return same time
assert sampler.rate_limiter.timestamp() == ts
sampled, _ = sampler.is_sampled(0)
assert sampled, 'initial balance allows first item'
sampled, _ = sampler.is_sampled(0)
assert not sampled, 'initial balance exhausted'
# move time 11s forward, enough credits to pay for one sample
mock_time.side_effect = lambda: ts + 11
sampled, _ = sampler.is_sampled(0)
assert sampled
sampler.close()
assert '%s' % sampler == 'RateLimitingSampler(0.1)'
# Test update
sampler = RateLimitingSampler(3.0)
sampler.rate_limiter.balance = 3.0
ts = time.time()
sampler.rate_limiter.last_tick = ts
with mock.patch('jaeger_client.rate_limiter.RateLimiter.timestamp') \
as mock_time:
mock_time.side_effect = lambda: ts # always return same time
assert sampler.rate_limiter.timestamp() == ts
sampled, _ = sampler.is_sampled(0)
assert sampled
assert sampler.rate_limiter.balance == 2.0
assert '%s' % sampler == 'RateLimitingSampler(3.0)'
sampler.update(3.0)
assert '%s' % sampler == \
'RateLimitingSampler(3.0)', 'should short cirtcuit if rate is the same'
sampler.update(2.0)
assert sampler.rate_limiter.balance == 4.0 / 3.0
assert '%s' % sampler == 'RateLimitingSampler(2.0)'
sampler.close()
