public async Task ExportAsyncCallsAllHandlers()
{
var exporter = SpanExporter.Create(4, Duration.Create(1, 0));
var handler1 = new Mock <IHandler>();
var handler2 = new Mock <IHandler>();
exporter.RegisterHandler("first", handler1.Object);
exporter.RegisterHandler("second", handler2.Object);
var span1 = new Mock <ISpanData>();
var span2 = new Mock <ISpanData>();
await exporter.ExportAsync(new ISpanData[] { span1.Object, span2.Object }, CancellationToken.None);
Assert.Single(handler1.Invocations);
var args = (IEnumerable <ISpanData>)handler1.Invocations.First().Arguments.First();
handler1.Verify(c => c.Export(It.Is <IEnumerable <ISpanData> >(
(x) => x.Where((s) => s == span1.Object).Count() > 0 &&
x.Where((s) => s == span2.Object).Count() > 0 &&
x.Count() == 2)));
handler2.Verify(c => c.Export(It.Is <IEnumerable <ISpanData> >(
(x) => x.Where((s) => s == span1.Object).Count() > 0 &&
x.Where((s) => s == span2.Object).Count() > 0 &&
x.Count() == 2)));
}
private TracerFactory(TracerBuilder builder)
{
this.sampler = builder.Sampler ?? Samplers.AlwaysSample;
// TODO separate sampler from options
this.configurationOptions =
builder.TracerConfigurationOptions ?? new TracerConfiguration(this.sampler);
// TODO log warning (or throw?) if there is no exporter
this.exporter = builder.SpanExporter ?? new NoopSpanExporter();
this.spanProcessor = builder.ProcessorFactory != null?
builder.ProcessorFactory(this.exporter) :
new BatchingSpanProcessor(this.exporter);
this.binaryFormat = builder.BinaryFormat ?? new BinaryFormat();
this.textFormat = builder.TextFormat ?? new TraceContextFormat();
this.defaultTracer = new Tracer(
this.spanProcessor,
this.configurationOptions,
this.binaryFormat,
this.textFormat,
Resource.Empty);
}
/// <summary>
/// Creates an instance of <see cref="ITracer"/>.
/// </summary>
/// <param name="startEndHandler">Start/end event handler.</param>
/// <param name="traceConfig">Trace configuration.</param>
/// <param name="spanExporter">Exporter for span.</param>
/// <param name="binaryFormat">Binary format context propagator.</param>
/// <param name="textFormat">Text format context propagator.</param>
public Tracer(IStartEndHandler startEndHandler, ITraceConfig traceConfig, SpanExporter spanExporter, IBinaryFormat binaryFormat, ITextFormat textFormat)
{
this.spanBuilderOptions = new SpanBuilderOptions(startEndHandler, traceConfig);
this.spanExporter = spanExporter ?? (SpanExporter)SpanExporter.Create(ExporterBufferSize, ExporterScheduleDelay);
this.BinaryFormat = binaryFormat ?? new BinaryFormat();
this.TextFormat = textFormat ?? new TraceContextFormat();
}
public async Task StartStopExporter()
{
var config = new TelemetryConfiguration {
TelemetryChannel = new StubTelemetryChannel(),
};
var exporter = new ApplicationInsightsExporter(SpanExporter.Create(), Stats.Stats.ViewManager, config);
exporter.Start();
await Task.Delay(100);
var sw = Stopwatch.StartNew();
exporter.Stop();
sw.Stop();
Assert.InRange(sw.ElapsedMilliseconds, 0, 1000);
}
public async Task ExportAsyncCallsAllHandlers()
{
var exporter = SpanExporter.Create(4, TimeSpan.FromSeconds(1));
var handler1 = new Mock <IHandler>();
exporter.RegisterHandler("first", handler1.Object);
var span1 = CreateSampledEndedSpan(SpanName1).ToSpanData();
await exporter.ExportAsync(span1, CancellationToken.None);
Assert.Single(handler1.Invocations);
var args = (IEnumerable <SpanData>)handler1.Invocations.First().Arguments.First();
handler1.Verify(c => c.ExportAsync(It.Is <IEnumerable <SpanData> >(
(x) => x.Any(s => s == span1) && x.Count() == 1)));
}
public async Task ExportAsyncCallsAllHandlers()
{
var exporter = SpanExporter.Create(4, Duration.Create(1, 0));
var handler1 = new Mock <IHandler>();
exporter.RegisterHandler("first", handler1.Object);
var span1 = CreateNotSampledEndedSpan(SPAN_NAME_1).ToSpanData();
await exporter.ExportAsync(span1, CancellationToken.None);
Assert.Single(handler1.Invocations);
var args = (IEnumerable <SpanData>)handler1.Invocations.First().Arguments.First();
handler1.Verify(c => c.ExportAsync(It.Is <IEnumerable <SpanData> >(
(x) => x.Where((s) => s == span1).Count() > 0 &&
x.Count() == 1)));
}
public TestProcessor(SpanExporter exporter)
{
this.exporter = exporter;
this.onEnd = null;
}
public TestProcessor(Action <SpanData> onEnd)
{
this.exporter = null;
this.onEnd = onEnd;
}
/// <summary>
/// Configures exporter.
/// </summary>
/// <param name="exporter">Exporter instance.</param>
public SpanProcessorPipelineBuilder SetExporter(SpanExporter exporter)
{
this.Exporter = exporter ?? throw new ArgumentNullException(nameof(exporter));
return(this);
}
public TracerBuilder SetExporter(SpanExporter spanExporter)
{
this.SpanExporter = spanExporter ?? throw new ArgumentNullException(nameof(spanExporter));
return(this);
}
public TestProcessor(SpanExporter exporter) : base(exporter)
{
}
