public void ProbabilisticSampler_Constructor_ShouldSetSamplingRate()
{
var samplingRate = 0.5;
var sampler = new ProbabilisticSampler(samplingRate);
Assert.Equal(samplingRate, sampler.SamplingRate);
sampler.Dispose();
}
public void TestTags()
{
ProbabilisticSampler sampler = new ProbabilisticSampler(0.1);
var tags = sampler.Sample("vadacurry", new TraceId(20L)).Tags;
Assert.Equal("probabilistic", tags["sampler.type"]);
Assert.Equal(0.1, tags["sampler.param"]);
}
public void SamplerSetsTheCorrectTags()
{
var sampler = new ProbabilisticSampler(0.43);
var sample = sampler.Sample("an op", ulong.MinValue);
Assert.Equal("probabilistic", sample.Tags["sampler"]);
Assert.Equal(0.43.ToString(), sample.Tags["sampler-arg"]);
}
public void ZeroProbabilityNeverSamplesAnyTrace()
{
var sampler = new ProbabilisticSampler(0);
Assert.False(sampler.Sample("op1", 0));
Assert.False(sampler.Sample("op2", 1));
Assert.False(sampler.Sample("op2.1", 8383));
Assert.False(sampler.Sample("op3", 89480932480));
}
public void OneProbabilitySamplesAllTraces()
{
var sampler = new ProbabilisticSampler(0.999);
Assert.True(sampler.Sample("op1", 0));
Assert.True(sampler.Sample("op2", 1));
Assert.True(sampler.Sample("op2.1", 8383));
Assert.True(sampler.Sample("op3", 89480932480));
Assert.True(sampler.Sample("op4", long.MaxValue));
}
public void TestSamplingBoundariesPositive()
{
double samplingRate = 0.5;
long halfwayBoundary = 0x3fffffffffffffffL;
ISampler sampler = new ProbabilisticSampler(samplingRate);
Assert.True(sampler.Sample("", new TraceId(halfwayBoundary)).IsSampled);
Assert.False(sampler.Sample("", new TraceId(halfwayBoundary + 2)).IsSampled);
}
public void TestSamplingBoundariesNegative()
{
double samplingRate = 0.5;
long halfwayBoundary = -0x4000000000000000L;
ISampler sampler = new ProbabilisticSampler(samplingRate);
Assert.True(sampler.Sample("", new TraceId(halfwayBoundary)).IsSampled);
Assert.False(sampler.Sample("", new TraceId(halfwayBoundary - 1)).IsSampled);
}
public PerOperationSamplerTests()
{
_loggerFactory = new NullLoggerFactory();
_defaultProbabilisticSampler = Substitute.ForPartsOf <ProbabilisticSampler>(0);
_undertest = new PerOperationSampler(MaxOperations, _operationToSamplers, _defaultProbabilisticSampler,
DefaultLowerBoundTracesPerSecond, _loggerFactory);
_defaultProbabilisticSampler.Sample(operation, TraceId)
.Returns(new SamplingStatus(true, EmptyTags));
_defaultProbabilisticSampler.SamplingRate.Returns(DefaultSamplingProbability);
}
private Tracer GetRemoteTracer(IMetrics metrics, IReporter reporter, string serviceName, string samplingHostPort)
{
ISampler initialSampler = new ProbabilisticSampler(1.0);
var manager = new HttpSamplingManager(samplingHostPort);
var remoteSampler = new RemoteControlledSampler.Builder(serviceName)
.WithSamplingManager(manager)
.WithInitialSampler(initialSampler)
.WithMetrics(metrics)
.WithPollingInterval(TimeSpan.FromSeconds(5))
.Build();
return(new Tracer.Builder(serviceName)
.WithReporter(reporter)
.WithSampler(remoteSampler)
.Build());
}
public void SamplerOnlySamplesLowerProbabilityBound(double probability)
{
var sampler = new ProbabilisticSampler(probability);
var sampled = sampler.Sample("abc", 1);
Assert.True(sampled);
var random = ulong.MaxValue * probability / 2 + 5;
Assert.True(sampler.Sample("something", (ulong)random));
var upperBound = (ulong)Math.Ceiling(ulong.MaxValue * probability);
Assert.False(sampler.Sample("upper", upperBound));
Assert.False(sampler.Sample("upper + 1", upperBound + 1));
Assert.False(sampler.Sample("upper + something", upperBound + 9894));
}
public void ProbabilisticSampler_IsSampled()
{
var middleId = 9223372036854775807;
var samplingRate = 0.5;
var expectedTags = new Dictionary <string, object> {
{ SamplerConstants.SamplerTypeTagKey, SamplerConstants.SamplerTypeProbabilistic },
{ SamplerConstants.SamplerParamTagKey, samplingRate }
};
var sampler = new ProbabilisticSampler(samplingRate);
var isSampled = sampler.IsSampled(new TraceId((ulong)(middleId + 10)), "op");
Assert.Equal(expectedTags, isSampled.Tags);
Assert.False(isSampled.Sampled);
isSampled = sampler.IsSampled(new TraceId((ulong)(middleId - 20)), "op");
Assert.Equal(expectedTags, isSampled.Tags);
Assert.True(isSampled.Sampled);
}
/// <summary>
/// Should be instantiated before any Http request takes place
/// </summary>
/// <param name="setupConfig"></param>
private SimpleTracingSetup(SimpleTracingSetupConfig setupConfig)
{
setupConfig.CheckValidity();
this._setupConfig = setupConfig;
var probabilisticSampler = new ProbabilisticSampler(this._setupConfig.TracingComponentsConfigProvider);
var debugModeSampler = new DebugModeSampler(probabilisticSampler, this._setupConfig.DebugModeConfig);
var sampler = new TracesThrottlerSampler(
new ParentBasedSampler(debugModeSampler),
this._setupConfig.TracingComponentsConfigProvider);
this._setupConfig.InstrumentationConfig.WithSampler(sampler);
var httpClientHeadersTracker = new ClientHeadersTracker(this._setupConfig.TracingComponentsConfigProvider);
this._setupConfig.InstrumentationConfig.HttpInstrumentationEnrichHooks.Add(httpClientHeadersTracker);
TracingSetup.PreConfigure(this._setupConfig.InstrumentationConfig);
this._startTraceHandler = new StartTraceHandler(
ActivityTracer.Singleton,
() => sampler.DecrementOngoingTraces(),
this._setupConfig.RouteTemplateProvider, this._setupConfig.DebugModeConfig,
this._setupConfig.TracingComponentsConfigProvider
);
this._periodicUpdater = new PeriodicUpdater(
this._setupConfig.ComponentsUpdateInterval,
this._setupConfig.ComponentsUpdateTimeout,
this._setupConfig.TracingComponentsConfigProvider,
new List <IConfigUpdatableComponent> {
probabilisticSampler, sampler, httpClientHeadersTracker, this._startTraceHandler
},
this._setupConfig.Logger, this._setupConfig.MetricsTracker);
this._periodicMetricsReporter = new PeriodicMetricsReporter(
this._setupConfig.ComponentsMetricsReportInterval,
new List <IMeasurableComponent> {
probabilisticSampler, debugModeSampler, sampler, this._startTraceHandler
},
this._setupConfig.Logger,
this._setupConfig.MetricsTracker);
}
public void TestNoopUpdate()
{
ProbabilisticSampler defaultProbabilisticSampler = new ProbabilisticSampler(DefaultSamplingProbability);
double operationSamplingRate = 0.23;
_operationToSamplers.Add(operation, new GuaranteedThroughputSampler(operationSamplingRate,
DefaultLowerBoundTracesPerSecond));
_undertest = new PerOperationSampler(MaxOperations, _operationToSamplers, defaultProbabilisticSampler,
DefaultLowerBoundTracesPerSecond, _loggerFactory);
var parametersList = new List <PerOperationSamplingParameters>();
parametersList.Add(new PerOperationSamplingParameters(operation, new ProbabilisticSamplingStrategy(operationSamplingRate)));
var parameters = new OperationSamplingParameters(DefaultSamplingProbability, DefaultLowerBoundTracesPerSecond, parametersList);
Assert.False(_undertest.Update(parameters));
Assert.Equal(_operationToSamplers, _undertest.OperationNameToSampler);
Assert.Equal(DefaultLowerBoundTracesPerSecond, _undertest.LowerBound, DoublePrecision);
Assert.Equal(DefaultSamplingProbability, _undertest.DefaultSampler.SamplingRate, DoublePrecision);
}
