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); }