コード例 #1
0
        private static SampleDecision ApplyRule(SamplingRule rule)
        {
            if (rule.RateLimiter.Request())
            {
                return(SampleDecision.Sampled);
            }

            return(ThreadSafeRandom.NextDouble() <= rule.Rate ? SampleDecision.Sampled : SampleDecision.NotSampled);
        }
コード例 #2
0
        /// <summary>
        /// Use X-Ray client to get the sampling rules
        /// from X-Ray service.The call is proxied and signed by X-Ray Daemon.
        /// </summary>
        /// <returns></returns>
        public async Task <GetSamplingRulesResponse> GetSamplingRules()
        {
            List <SamplingRule>     newRules = new List <SamplingRule>();
            GetSamplingRulesRequest request  = new GetSamplingRulesRequest();

            var response = await _xrayClient.GetSamplingRulesAsync(request);

            foreach (var record in response.SamplingRuleRecords)
            {
                var rule = record.SamplingRule;
                if (rule.Version == Version && SamplingRule.IsValid(rule)) // We currently only handle v1 sampling rules.
                {
                    var sampleRule = new SamplingRule(rule.RuleName, rule.Priority, rule.FixedRate, rule.ReservoirSize, rule.Host, rule.ServiceName, rule.HTTPMethod, rule.URLPath, rule.ServiceType, rule.ResourceARN, rule.Attributes);
                    newRules.Add(sampleRule);
                }
            }

            GetSamplingRulesResponse result = new GetSamplingRulesResponse(newRules);

            return(result);
        }
コード例 #3
0
        private SamplingResponse ProcessMatchedRule(SamplingRule sampleRule, TimeStamp time)
        {
            bool             shouldSample = true;
            Reservoir        reservoir    = sampleRule.Reservoir;
            SamplingResponse sampleResult = null;

            sampleRule.IncrementRequestCount();                                                       // increment request counter for matched rule
            ReservoirDecision reservoirDecision = reservoir.BorrowOrTake(time, sampleRule.CanBorrow); // check if we can borrow or take from reservoir

            if (reservoirDecision == ReservoirDecision.Borrow)
            {
                sampleRule.IncrementBorrowCount();
            }
            else if (reservoirDecision == ReservoirDecision.Take)
            {
                sampleRule.IncrementSampledCount();
            }
            else if (ThreadSafeRandom.NextDouble() <= sampleRule.GetRate()) // compute based on fixed rate
            {
                sampleRule.IncrementSampledCount();
            }
            else
            {
                shouldSample = false;
            }

            if (shouldSample)
            {
                sampleResult = new SamplingResponse(sampleRule.RuleName, SampleDecision.Sampled);
            }
            else
            {
                sampleResult = new SamplingResponse(SampleDecision.NotSampled);
            }

            return(sampleResult);
        }