def test_probabilistic_sampler():
sampler = ProbabilisticSampler(0.5)
assert MAX_INT == 0x8000000000000000
sampled, tags = sampler.is_sampled(MAX_INT - 10)
assert sampled
assert tags == get_tags('probabilistic', 0.5)
sampled, _ = sampler.is_sampled(MAX_INT + 10)
assert not sampled
sampler.close()
assert '%s' % sampler == 'ProbabilisticSampler(0.5)'
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 _setup_default_sampling(self):
"""
Setup default sampling of zero probablistic sampling
:return:
"""
with self.lock:
new_sampler = ProbabilisticSampler(ZERO_SAMPLING_PROBABILITY)
self._replace_sampler(new_sampler)
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 test_probabilistic_sampler():
sampler = ProbabilisticSampler(0.5)
assert MAX_INT == 0x8000000000000000
sampled, tags = sampler.is_sampled(MAX_INT-10)
assert sampled
assert tags == get_tags('probabilistic', 0.5)
sampled, _ = sampler.is_sampled(MAX_INT+10)
assert not sampled
sampler.close()
assert '%s' % sampler == 'ProbabilisticSampler(0.5)'
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)
def test_probabilistic_sampler_errors():
with pytest.raises(AssertionError):
ProbabilisticSampler(-0.1)
with pytest.raises(AssertionError):
ProbabilisticSampler(1.1)
return_value.result = lambda *args: \
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,
),
(
