It has small probability will be panic about go2sky HOT 5 CLOSED

func (s *RandomSampler) IsSampled(operation string) bool {
	return s.threshold > s.rand.Intn(100)
}

// RandomMutexSampler Use mutex to implement concurrent-safe for randomizer.
type RandomMutexSampler struct {
	mutex        sync.Mutex
	samplingRate float64
	rand         *rand.Rand
	threshold    int
}

// IsSampled implements IsSampled() of Sampler.
func (s *RandomMutexSampler) IsSampled(operation string) bool {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	return s.threshold > s.rand.Intn(100)
}

func (s *RandomMutexSampler) init() {
	s.rand = rand.New(rand.NewSource(time.Now().Unix()))
	s.threshold = int(s.samplingRate * 100)
}

func NewRandomMutexSampler(samplingRate float64) *RandomMutexSampler {
	s := &RandomMutexSampler{
		samplingRate: samplingRate,
	}
	s.init()
	return s
}

// RandomChannelSampler Use channel to implement concurrent-safe for randomizer.
type RandomChannelSampler struct {
	samplingRate        float64
	randomNumberChannel chan int
	rand                *rand.Rand
	threshold           int
}

// IsSampled implements IsSampled() of Sampler.
func (s *RandomChannelSampler) IsSampled(operation string) bool {
	n := <-s.randomNumberChannel
	return s.threshold > n
}

func (s *RandomChannelSampler) init() {
	s.rand = rand.New(rand.NewSource(time.Now().Unix()))
	s.threshold = int(s.samplingRate * 100)
	go func() {
		for {
			s.randomNumberChannel <- s.rand.Intn(100)
		}
	}()
}

func NewRandomChannelSampler(samplingRate float64, channelSize int) *RandomChannelSampler {
	s := &RandomChannelSampler{
		samplingRate:        samplingRate,
		randomNumberChannel: make(chan int, channelSize),
	}
	s.init()
	return s
}

// RandomGlobalSampler Use global randomizer to ensure concurrent-safe, it's used a local lock too.
type RandomGlobalSampler struct {
	samplingRate float64
	threshold    int
}

// IsSampled implements IsSampled() of Sampler.
func (s *RandomGlobalSampler) IsSampled(operation string) bool {
	return s.threshold > rand.Intn(100)
}

func (s *RandomGlobalSampler) init() {
	s.threshold = int(s.samplingRate * 100)
}

func NewRandomGlobalSampler(samplingRate float64) *RandomGlobalSampler {
	s := &RandomGlobalSampler{
		samplingRate: samplingRate,
	}
	s.init()
	return s
}

// RandomPoolSampler Use sync.Pool to implement concurrent-safe for randomizer.
type RandomPoolSampler struct {
	samplingRate float64
	threshold    int
	initCount    int
	pool         sync.Pool
}

// IsSampled implements IsSampled() of Sampler.
func (s *RandomPoolSampler) IsSampled(operation string) bool {

	return s.threshold > s.generateRandomNumber()
}

func (s *RandomPoolSampler) init() {
	s.threshold = int(s.samplingRate * 100)
	for i := 0; i < s.initCount; i++ {
		s.pool.Put(s.newRand())
	}
	s.pool.New = s.newRand
}

func (s *RandomPoolSampler) generateRandomNumber() int {

	r := s.getRandomizer()

	randomNumber := r.Intn(100)

	s.returnRandomizer(r)

	return randomNumber
}

func (s *RandomPoolSampler) returnRandomizer(r *rand.Rand) {
	s.pool.Put(r)
}

func (s *RandomPoolSampler) getRandomizer() *rand.Rand {

	var r *rand.Rand

	generator := s.pool.Get()
	if generator == nil {
		generator = s.newRand()
	}

	r, ok := generator.(*rand.Rand)
	if !ok {
		r = s.newRand().(*rand.Rand) // it must be *rand.Rand
	}

	return r
}

func (s *RandomPoolSampler) newRand() interface{} {
	return rand.New(rand.NewSource(time.Now().UnixNano()))
}

func NewRandomPoolSampler(samplingRate float64, initCount int) *RandomPoolSampler {
	s := &RandomPoolSampler{
		samplingRate: samplingRate,
		initCount:    initCount,
	}
	s.init()
	return s
}

func BenchmarkRandomSampler_IsSampled(b *testing.B) {
	sampler := NewRandomSampler(0.5)
	operationName := "op"
	// will be panic
	/*b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})*/
	// Only run serial
	for i := 0; i < b.N; i++ {
		sampler.IsSampled(operationName)
	}
}

func BenchmarkRandomMutexSampler_IsSampled(b *testing.B) {
	sampler := NewRandomMutexSampler(0.5)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomGlobalSampler_IsSampled(b *testing.B) {
	sampler := NewRandomGlobalSampler(0.5)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomChannelSampler0_IsSampled(b *testing.B) {
	sampler := NewRandomChannelSampler(0.5, 0)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomChannelSampler1_IsSampled(b *testing.B) {
	sampler := NewRandomChannelSampler(0.5, 1)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomChannelSampler128_IsSampled(b *testing.B) {
	sampler := NewRandomChannelSampler(0.5, 128)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomChannelSampler1024_IsSampled(b *testing.B) {
	sampler := NewRandomChannelSampler(0.5, 1024)
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}

func BenchmarkRandomPoolSampler_IsSampled(b *testing.B) {
	sampler := NewRandomPoolSampler(0.5, runtime.NumCPU())
	operationName := "op"
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			sampler.IsSampled(operationName)
		}
	})
}