public void UseApplicationInsights_BadArgs()
{
TracerBuilder builder = null;
Assert.Throws <ArgumentNullException>(() => builder.UseApplicationInsights(_ => { }));
Assert.Throws <ArgumentNullException>(() => TracerFactory.Create(b => b.UseApplicationInsights(null)));
}
public void AddDependencyInstrumentation_BadArgs()
{
TracerBuilder builder = null;
Assert.Throws <ArgumentNullException>(() => builder.AddDependencyInstrumentation());
Assert.Throws <ArgumentNullException>(() => builder.AddDependencyInstrumentation(null, null));
}
/// <summary>
/// Registers Console exporter.
/// </summary>
/// <param name="builder">Trace builder to use.</param>
/// <param name="configure">Exporter configuration options.</param>
/// <param name="processorConfigure">Span processor configuration.</param>
/// <returns>The instance of <see cref="TracerBuilder"/> to chain the calls.</returns>
public static TracerBuilder UseConsole(this TracerBuilder builder, Action <ConsoleExporterOptions> configure, Action <SpanProcessorPipelineBuilder> processorConfigure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
if (processorConfigure == null)
{
throw new ArgumentNullException(nameof(processorConfigure));
}
var options = new ConsoleExporterOptions();
configure(options);
return(builder.AddProcessorPipeline(b =>
{
b.SetExporter(new ConsoleExporter(options));
processorConfigure.Invoke(b);
}));
}
/// <summary>
/// Enables OpenTelemetry Protocol (OTLP) exporter.
/// </summary>
/// <param name="builder">Trace builder to use.</param>
/// <param name="configure">Configuration action.</param>
/// <param name="processorConfigure">Span processor configuration action.</param>
/// <returns>The instance of <see cref="TracerBuilder"/> to chain the calls.</returns>
public static TracerBuilder UseOpenTelemetryProtocolExporter(
this TracerBuilder builder, Action <ExporterOptions> configure, Action <SpanProcessorPipelineBuilder> processorConfigure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
if (processorConfigure == null)
{
throw new ArgumentNullException(nameof(processorConfigure));
}
var configuration = new ExporterOptions();
configure(configuration);
return(builder.AddProcessorPipeline(b =>
{
b.SetExporter(new TraceExporter(configuration));
processorConfigure.Invoke(b);
}));
}
public void AddDependencyCollector_BadArgs()
{
TracerBuilder builder = null;
Assert.Throws <ArgumentNullException>(() => builder.AddDependencyCollector());
Assert.Throws <ArgumentNullException>(() => builder.AddDependencyCollector(null, null));
}
public void DefaultBasicTracer_WhenExtractValidSpanToMemoryCarrier_Works()
{
var spanContextFactory = new OpenTracingSpanContextFactory();
var traceBuilder = new TracerBuilder <OpenTracingSpanContext>();
traceBuilder.SetSpanContextFactory(spanContextFactory);
var tracer = traceBuilder.BuildTracer();
var testTraceId = 1234;
var testSpanId = 9876;
var data = new Dictionary <string, string>()
{
{ "ot-tracer-traceid", testTraceId.ToString() },
{ "ot-tracer-spanid", testSpanId.ToString() },
};
var memoryCarrier = new MemoryTextMapCarrier(data);
var extractResult = tracer.Extract("TestOperation", memoryCarrier);
Assert.IsTrue(extractResult.Success);
Assert.IsTrue(extractResult.SpanContext is OpenTracingSpanContext);
Assert.AreEqual(testTraceId.ToString(), memoryCarrier.TextMap["ot-tracer-traceid"]);
Assert.AreEqual(testSpanId.ToString(), memoryCarrier.TextMap["ot-tracer-spanid"]);
}
public void AddRequestAdapter_BadArgs()
{
TracerBuilder builder = null;
Assert.Throws <ArgumentNullException>(() => builder.AddRequestAdapter());
Assert.Throws <ArgumentNullException>(() => TracerFactory.Create(b => b.AddRequestAdapter(null)));
}
public static TracerBuilder AddDelegateExporter(this TracerBuilder builder,
OnProcessFunc onProcess,
OnFinishFunc onShutdown = null)
{
return(builder.AddProcessorPipeline((cfg) =>
cfg.SetExporter(new DelegateExporter(onProcess, onShutdown))
.SetExportingProcessor(e => new SimpleSpanProcessor(e))));
}
public static TracerBuilder AddRequestCollector(this TracerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddCollector(t => new AspNetCoreCollector(t)));
}
/// <summary>
/// Tracing Configuration builder.
/// </summary>
/// <param name="tracerBuilder">The <see cref="TracerBuilder"/>.</param>
/// <param name="exporters"> A <see cref="IDictionary{String, BasicExporterOptions}" /> of exporters.</param>
/// <param name="configuration">The <see cref="IConfiguration"/> which binds to <see cref="TracingOptions"/>.</param>
public TracingConfigurationBuilder(
[NotNull] TracerBuilder tracerBuilder,
[NotNull] IDictionary <string, BasicExporterOptions> exporters,
[NotNull] IConfiguration configuration)
{
_exporters = exporters ?? throw new ArgumentNullException(nameof(exporters));
_tracerBuilder = tracerBuilder ?? throw new ArgumentNullException(nameof(tracerBuilder));
TracingConfiguration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
public void TracerBuilder_ValidArgs()
{
var builder = new TracerBuilder();
bool processorFactoryCalled = false;
bool collectorFactoryCalled = true;
var sampler = new ProbabilitySampler(0.1);
var exporter = new TestExporter(_ => { });
var options = new TracerConfiguration(1, 1, 1);
var binaryFormat = new BinaryFormat();
var textFormat = new TraceContextFormat();
builder
.SetSampler(sampler)
.AddProcessorPipeline(p => p
.SetExporter(exporter)
.SetExportingProcessor(e =>
{
processorFactoryCalled = true;
Assert.Same(e, exporter);
return(new SimpleSpanProcessor(e));
}))
.SetTracerOptions(options)
.SetBinaryFormat(binaryFormat)
.SetTextFormat(textFormat)
.AddCollector(t =>
{
Assert.NotNull(t);
return(new TestCollector(t));
});
Assert.Same(sampler, builder.Sampler);
Assert.NotNull(builder.ProcessingPipelines);
Assert.Single(builder.ProcessingPipelines);
Assert.Same(exporter, builder.ProcessingPipelines[0].Exporter);
Assert.NotNull(builder.ProcessingPipelines[0].Build());
Assert.True(processorFactoryCalled);
Assert.Same(options, builder.TracerConfigurationOptions);
Assert.Same(binaryFormat, builder.BinaryFormat);
Assert.Same(textFormat, builder.TextFormat);
Assert.Single(builder.CollectorFactories);
var collectorFactory = builder.CollectorFactories.Single();
Assert.Equal(nameof(TestCollector), collectorFactory.Name);
Assert.Equal("semver:" + typeof(TestCollector).Assembly.GetName().Version, collectorFactory.Version);
Assert.NotNull(collectorFactory.Factory);
collectorFactory.Factory(new Tracer(new SimpleSpanProcessor(exporter), new AlwaysSampleSampler(), options, binaryFormat, textFormat,
Resource.Empty));
Assert.True(collectorFactoryCalled);
}
public void TracerBuilder_Defaults()
{
var builder = new TracerBuilder();
Assert.Null(builder.Sampler);
Assert.Null(builder.ProcessingPipelines);
Assert.Null(builder.TracerConfigurationOptions);
Assert.Null(builder.InstrumentationFactories);
}
public void RegisterExporter(TracerBuilder builder)
{
builder.UseZipkin(o =>
{
o.ServiceName = _options.ServiceName;
o.Endpoint = _options.Endpoint;
o.TimeoutSeconds = _options.TimeoutSeconds;
o.UseShortTraceIds = _options.UseShortTraceIds;
});
}
public static TracerBuilder UseMonitor(this TracerBuilder builder, IServiceProvider serviceProvider)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddProcessorPipeline(b => b
.SetExporter(serviceProvider.GetService(typeof(MonitorExporter)) as MonitorExporter)
.SetExportingProcessor(e => new BatchingSpanProcessor(e))));
}
public void TracerBuilder_Defaults()
{
var builder = new TracerBuilder();
Assert.Null(builder.Sampler);
Assert.Null(builder.ProcessingPipelines);
Assert.Null(builder.BinaryFormat);
Assert.Null(builder.TextFormat);
Assert.Null(builder.TracerConfigurationOptions);
Assert.Null(builder.CollectorFactories);
}
public void RegisterExporter(TracerBuilder builder)
{
builder.UseJaeger(o =>
{
o.ServiceName = _options.ServiceName;
o.AgentHost = _options.AgentHost;
o.AgentPort = _options.AgentPort;
o.MaxPacketSize = _options.MaxPacketSize;
o.MaxFlushInterval = _options.MaxFlushInterval;
});
}
public static void UseZipkinWithTraceOptions(this TracerBuilder builder, IServiceCollection services)
{
var options = services.BuildServiceProvider().GetService <ITraceExporterOptions>();
builder.UseZipkin(zipkinOptions =>
{
zipkinOptions.Endpoint = new Uri(options.Endpoint);
zipkinOptions.ServiceName = options.ServiceName;
zipkinOptions.TimeoutSeconds = new TimeSpan(0, 0, options.TimeoutSeconds);
zipkinOptions.UseShortTraceIds = options.UseShortTraceIds;
});
}
public static TracerBuilder AddNServiceBusAdapter(this TracerBuilder builder, Action <NServiceBusInstrumentationOptions> configureInstrumentationOptions)
{
var options = new NServiceBusInstrumentationOptions();
configureInstrumentationOptions ??= opt => { };
configureInstrumentationOptions(options);
return(builder
.AddAdapter(t => new NServiceBusReceiveAdapter(t, options))
.AddAdapter(t => new NServiceBusSendAdapter(t, options)));
}
public static TracerBuilder AddDependencyCollector(this TracerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder
.AddCollector((t) => new AzureClientsCollector(t))
.AddCollector((t) => new AzurePipelineCollector(t))
.AddCollector((t) => new HttpClientCollector(t)));
}
public void DefaultBasicTracer_WhenStartSpanCalled_ReturnsSpan()
{
var spanContextFactory = new OpenTracingSpanContextFactory();
var traceBuilder = new TracerBuilder <OpenTracingSpanContext>();
traceBuilder.SetSpanContextFactory(spanContextFactory);
var tracer = traceBuilder.BuildTracer();
var span = tracer.BuildSpan("TestOperation").Start();
Assert.NotNull(span);
}
public static TracerBuilder UseEventSource(this TracerBuilder builder, EventSourceCollectorOption option)
{
builder.AddAdapter(tracer =>
{
var collector = new EventSourceAdapter(tracer, option.ConvertFunc, option.IsEnableFunc);
foreach (var(ev, evoption) in option.Events)
{
collector.Add(ev, evoption);
}
return(collector);
});
return(builder);
}
public void TracerBuilder_ValidArgs()
{
var builder = new TracerBuilder();
bool processorFactoryCalled = false;
bool instrumentationFactoryCalled = true;
var sampler = new ProbabilitySampler(0.1);
var exporter = new TestSpanExporter(_ => { });
var options = new TracerConfiguration(1, 1, 1);
builder
.SetSampler(sampler)
.AddProcessorPipeline(p => p
.SetExporter(exporter)
.SetExportingProcessor(e =>
{
processorFactoryCalled = true;
Assert.Same(e, exporter);
return(new SimpleSpanProcessor(e));
}))
.SetTracerOptions(options)
.AddInstrumentation(t =>
{
Assert.NotNull(t);
return(new TestInstrumentation(t));
});
Assert.Same(sampler, builder.Sampler);
Assert.NotNull(builder.ProcessingPipelines);
Assert.Single(builder.ProcessingPipelines);
Assert.Same(exporter, builder.ProcessingPipelines[0].Exporter);
Assert.NotNull(builder.ProcessingPipelines[0].Build());
Assert.True(processorFactoryCalled);
Assert.Same(options, builder.TracerConfigurationOptions);
Assert.Single(builder.InstrumentationFactories);
var instrumentationFactory = builder.InstrumentationFactories.Single();
Assert.Equal(nameof(TestInstrumentation), instrumentationFactory.Name);
Assert.Equal("semver:" + typeof(TestInstrumentation).Assembly.GetName().Version, instrumentationFactory.Version);
Assert.NotNull(instrumentationFactory.Factory);
instrumentationFactory.Factory(new TracerSdk(new SimpleSpanProcessor(exporter), new AlwaysOnSampler(), options, Resource.Empty));
Assert.True(instrumentationFactoryCalled);
}
public static TracerBuilder UseEventSource(this TracerBuilder builder, IEnumerable <KeyValuePair <EventSource, EventLevel> > events, Func <EventWrittenEventArgs, Event> convertFunc = null)
{
builder.AddAdapter(tracer =>
{
var collector = new EventSourceAdapter(tracer, convertFunc);
foreach (var pair in events)
{
collector.Add(pair.Key, new EventEnableOption()
{
Level = pair.Value
});
}
return(collector);
});
return(builder);
}
public void DefaultBasicTracer_WhenExtractBadSpanToMemoryCarrier_Fails()
{
var spanContextFactory = new OpenTracingSpanContextFactory();
var traceBuilder = new TracerBuilder <OpenTracingSpanContext>();
traceBuilder.SetSpanContextFactory(spanContextFactory);
var tracer = traceBuilder.BuildTracer();
var memoryCarrier = new MemoryTextMapCarrier(new Dictionary <string, string>()
{
});
var extractResult = tracer.Extract("TestOperation", memoryCarrier);
Assert.IsFalse(extractResult.Success);
}
public static TracerBuilder UseApplicationInsights(this TracerBuilder builder, Action <TelemetryConfiguration> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var configuration = new TelemetryConfiguration();
configure(configuration);
return(builder.SetExporter(new ApplicationInsightsTraceExporter(configuration)));
}
public static TracerBuilder UseZipkin(this TracerBuilder builder, Action <ZipkinTraceExporterOptions> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var options = new ZipkinTraceExporterOptions();
configure(options);
return(builder.SetExporter(new ZipkinTraceExporter(options)));
}
public static TracerBuilder AddRequestCollector(this TracerBuilder builder, Action <AspNetCoreCollectorOptions> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var options = new AspNetCoreCollectorOptions();
configure(options);
return(builder.AddCollector(t => new AspNetCoreCollector(t, options)));
}
/// <summary>
/// Enables OpenTelemetry Protocol (OTLP) exporter.
/// </summary>
/// <param name="builder">Trace builder to use.</param>
/// <param name="configure">Configuration action.</param>
/// <returns>The instance of <see cref="TracerBuilder"/> to chain the calls.</returns>
public static TracerBuilder UseOpenTelemetryProtocolExporter(this TracerBuilder builder, Action <ExporterOptions> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var configuration = new ExporterOptions();
configure(configuration);
return(builder.AddProcessorPipeline(b => b
.SetExporter(new TraceExporter(configuration))
.SetExportingProcessor(e => new BatchingSpanProcessor(e))));
}
/// <summary>
/// Registers a Console exporter.
/// </summary>
/// <param name="builder">Trace builder to use.</param>
/// <param name="configure">Exporter configuration options.</param>
/// <returns>The instance of <see cref="TracerBuilder"/> to chain the calls.</returns>
public static TracerBuilder UseConsole(this TracerBuilder builder, Action <ConsoleExporterOptions> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var options = new ConsoleExporterOptions();
configure(options);
return(builder.AddProcessorPipeline(b => b
.SetExporter(new ConsoleExporter(options))
.SetExportingProcessor(e => new SimpleSpanProcessor(e))));
}
public void DefaultBasicTracer_WhenSpanInjectedToMemoryCarrier_Work()
{
var spanContextFactory = new OpenTracingSpanContextFactory();
var traceBuilder = new TracerBuilder <OpenTracingSpanContext>();
traceBuilder.SetSpanContextFactory(spanContextFactory);
var tracer = traceBuilder.BuildTracer();
var span = tracer.BuildSpan("TestOperation").Start();
var memoryCarrier = new MemoryTextMapCarrier();
tracer.Inject(span.GetSpanContext(), memoryCarrier);
Assert.IsTrue(memoryCarrier.TextMap.ContainsKey("ot-tracer-traceid"));
Assert.IsTrue(memoryCarrier.TextMap.ContainsKey("ot-tracer-spanid"));
Assert.IsTrue(ulong.Parse(memoryCarrier.TextMap["ot-tracer-traceid"]) != 0);
Assert.IsTrue(ulong.Parse(memoryCarrier.TextMap["ot-tracer-spanid"]) != 0);
}
