public void TraceFactory_SetDefault()
{
var factory = TracerFactory.Create(b => { });
TracerFactoryBase.SetDefault(factory);
var defaultTracer = TracerFactoryBase.Default.GetTracer("");
Assert.NotNull(defaultTracer);
Assert.IsType <TracerSdk>(defaultTracer);
Assert.NotSame(defaultTracer, TracerFactoryBase.Default.GetTracer("named tracerSdk"));
var span = defaultTracer.StartSpan("foo");
Assert.IsType <SpanSdk>(span);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, TracerFactory factory)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMiddleware <CallbackMiddleware>();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public void TraceFactory_UpdateDefault_CachedTracer()
{
var defaultTracer = TracerFactoryBase.Default.GetTracer("");
var noopSpan = defaultTracer.StartSpan("foo");
Assert.IsType <BlankSpan>(noopSpan);
TracerFactoryBase.SetDefault(TracerFactory.Create(b => { }));
var span = defaultTracer.StartSpan("foo");
Assert.IsType <SpanSdk>(span);
var newDefaultTracer = TracerFactoryBase.Default.GetTracer("");
Assert.NotSame(defaultTracer, newDefaultTracer);
Assert.IsType <TracerSdk>(newDefaultTracer);
}
public void CreateFactory_DefaultBuilder()
{
var tracerFactory = TracerFactory.Create(b => { });
var tracer = tracerFactory.GetTracer("");
Assert.NotNull(tracer);
Assert.IsType <TracerSdk>(tracer);
var span = tracer.StartSpan("foo");
Assert.NotNull(span);
Assert.IsType <SpanSdk>(span);
// default sampler is always sample
Assert.True(span.IsRecording);
Assert.Equal(Resource.Empty, ((SpanSdk)span).LibraryResource);
}
public void GetTracerReturnsTracerWithResourceOverriddenBySetResource()
{
var tracerFactory = TracerFactory.Create(b =>
{
b.SetResource(new Resource(new Dictionary <string, object>()
{
{ "a", "b" }
}))
.SetResource(new Resource(new Dictionary <string, object>()
{
{ "a", "c" }
}));
});
var tracer = (TracerSdk)tracerFactory.GetTracer("foo", "semver:1.2.3");
Assert.Equal("c", tracer.LibraryResource.Attributes.Single(kvp => kvp.Key == "a").Value);
}
public void BroadcastProcessor_CallsAllProcessorSequentially()
{
bool start1Called = false;
bool start2Called = false;
bool end1Called = false;
bool end2Called = false;
var processor1 = new TestProcessor(ss =>
{
start1Called = true;
Assert.False(start2Called);
Assert.False(end1Called);
Assert.False(end2Called);
}, se =>
{
end1Called = true;
Assert.True(start1Called);
Assert.True(start2Called);
Assert.False(end2Called);
});
var processor2 = new TestProcessor(ss =>
{
start2Called = true;
Assert.True(start1Called);
Assert.False(end1Called);
Assert.False(end2Called);
}, se =>
{
end2Called = true;
Assert.True(start1Called);
Assert.True(start2Called);
Assert.True(end1Called);
});
var broadcastProcessor = new BroadcastProcessor(new [] { processor1, processor2 });
var tracer = TracerFactory.Create(_ => { }).GetTracer(null);
var span = (Span)tracer.StartSpan("foo");
broadcastProcessor.OnStart(span);
Assert.True(start1Called);
Assert.True(start2Called);
broadcastProcessor.OnEnd(span);
Assert.True(end1Called);
Assert.True(end2Called);
}
public async Task CustomTextFormat()
{
var spanProcessor = new Mock <SpanProcessor>();
var expectedTraceId = ActivityTraceId.CreateRandom();
var expectedSpanId = ActivitySpanId.CreateRandom();
var textFormat = new Mock <ITextFormat>();
textFormat.Setup(m => m.Extract <HttpRequest>(It.IsAny <HttpRequest>(), It.IsAny <Func <HttpRequest, string, IEnumerable <string> > >())).Returns(new SpanContext(
expectedTraceId,
expectedSpanId,
ActivityTraceFlags.Recorded,
true));
// Arrange
using (var testFactory = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(services =>
{
services.AddSingleton <TracerFactory>(_ =>
TracerFactory.Create(b => b
.SetTextFormat(textFormat.Object)
.AddProcessorPipeline(p => p.AddProcessor(n => spanProcessor.Object))
.AddRequestCollector()));
})))
using (var client = testFactory.CreateClient())
{
var response = await client.GetAsync("/api/values/2");
response.EnsureSuccessStatusCode(); // Status Code 200-299
WaitForProcessorInvocations(spanProcessor, 2);
}
Assert.Equal(2, spanProcessor.Invocations.Count); // begin and end was called
var span = (SpanData)spanProcessor.Invocations[1].Arguments[0];
Assert.Equal(SpanKind.Server, span.Kind);
Assert.Equal("api/Values/{id}", span.Name);
Assert.Equal("/api/values/2", span.Attributes.GetValue("http.path"));
Assert.Equal(expectedTraceId, span.Context.TraceId);
Assert.Equal(expectedSpanId, span.ParentSpanId);
}
public async void ProfilerSessionUsesTheSameDefault()
{
var spanProcessor = new Mock <SpanProcessor>();
var tracer = TracerFactory.Create(b => b
.AddProcessorPipeline(p => p.AddProcessor(_ => spanProcessor.Object)))
.GetTracer(null);
using var instrumentation = new StackExchangeRedisCallsInstrumentation(tracer);
var profilerFactory = instrumentation.GetProfilerSessionsFactory();
var first = profilerFactory();
var second = profilerFactory();
ProfilingSession third = null;
await Task.Delay(1).ContinueWith((t) => { third = profilerFactory(); });
Assert.Equal(first, second);
Assert.Equal(second, third);
}
/// <summary>
/// Ons the window event.
/// </summary>
private void onWindowEvent()
{
debug("MainWindow.onWindowEvent()");
if (comportWindow.hasChanged())
{
if (comportWindow.isValid())
{
startNewTrace();
}
}
if (progressTraceWindow.hasChanged())
{
TracerFactory.getInstance().getInterface().stopTracing();
loadTracesIntoList();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddOpenTelemetry((svcProvider, tracerBuilder) =>
{
// Make the logger factory available to the dependency injection
// container so that it may be injected into the OpenTelemetry Tracer.
var loggerFactory = svcProvider.GetRequiredService <ILoggerFactory>();
// Adds the New Relic Exporter loading settings from the appsettings.json
var tracerFactory = TracerFactory.Create(b => b.UseNewRelic(Configuration, loggerFactory)
.SetSampler(Samplers.AlwaysSample));
var dependenciesCollector = new DependenciesCollector(new HttpClientCollectorOptions(), tracerFactory);
var aspNetCoreCollector = new AspNetCoreCollector(tracerFactory.GetTracer(null));
});
}
public async Task SuccessfulTemplateControllerCallUsesParentContext()
{
var spanProcessor = new Mock <SpanProcessor>(new NoopSpanExporter());
var expectedTraceId = ActivityTraceId.CreateRandom();
var expectedSpanId = ActivitySpanId.CreateRandom();
var tf = new Mock <ITextFormat>();
tf.Setup(m => m.Extract <HttpRequest>(It.IsAny <HttpRequest>(), It.IsAny <Func <HttpRequest, string, IEnumerable <string> > >())).Returns(new SpanContext(
expectedTraceId,
expectedSpanId,
ActivityTraceFlags.Recorded));
var tracerFactory = new TracerFactory(spanProcessor.Object, null, tf.Object);
// Arrange
using (var client = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(services =>
{
services.AddSingleton <ITracer>(tracerFactory.GetTracer(null));
}))
.CreateClient())
{
// Act
var response = await client.GetAsync("/api/values/2");
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
WaitForProcessorInvocations(spanProcessor, 2);
}
Assert.Equal(2, spanProcessor.Invocations.Count); // begin and end was called
var span = ((Span)spanProcessor.Invocations[1].Arguments[0]);
Assert.Equal(SpanKind.Server, span.Kind);
Assert.Equal("api/Values/{id}", span.Name);
Assert.Equal("/api/values/2", span.Attributes.GetValue("http.path"));
Assert.Equal(expectedTraceId, span.Context.TraceId);
Assert.Equal(expectedSpanId, span.ParentSpanId);
}
public void Merge_DoesNotDuplicateMethodMatchers_WhenContextSame()
{
TracerFactory first = new TracerFactory();
Match firstMatch = new Match()
{
AssemblyName = "Test", ClassName = "TestClass"
};
firstMatch.Matches.Add(new ExactMethodMatcher("TestMethod1", new[] { "ParamType1", "ParamType2" }));
first.MatchDefinitions.Add(firstMatch);
TracerFactory second = new TracerFactory();
Match secondMatch = new Match()
{
AssemblyName = firstMatch.AssemblyName, ClassName = firstMatch.ClassName
};
secondMatch.Matches.Add(new ExactMethodMatcher("TestMethod1", new[] { "ParamType1", "ParamType2" }));
second.MatchDefinitions.Add(secondMatch);
Extension firstExtension = new Extension();
firstExtension.Instrumentation.TracerFactories.Add(first);
Extension secondExtension = new Extension();
secondExtension.Instrumentation.TracerFactories.Add(second);
Extension merged = Extension.Merge(firstExtension, secondExtension);
Assert.AreEqual(1, merged.Instrumentation.TracerFactories.Count());
Assert.IsTrue(string.IsNullOrWhiteSpace(merged.Instrumentation.TracerFactories.First().MetricName));
Assert.AreEqual(Metric.Unspecified, merged.Instrumentation.TracerFactories.First().Metric);
Assert.AreEqual(1, merged.Instrumentation.TracerFactories.First().MatchDefinitions.Count);
var firstMergedMatch = merged.Instrumentation.TracerFactories.First().MatchDefinitions.First();
Assert.AreEqual("Test", firstMergedMatch.AssemblyName);
Assert.AreEqual("TestClass", firstMergedMatch.ClassName);
Assert.AreEqual(1, firstMergedMatch.Matches.Count);
Assert.AreEqual("TestMethod1", firstMergedMatch.Matches.First().MethodName);
Assert.AreEqual("ParamType1,ParamType2", string.Join(",", firstMergedMatch.Matches.First().ParameterTypes));
}
internal static object Run(string projectId)
{
var spanExporter = new StackdriverTraceExporter(projectId);
var metricExporter = new StackdriverMetricExporter(
projectId,
Stats.ViewManager);
metricExporter.Start();
using (var tracerFactory = TracerFactory.Create(builder => builder.SetExporter(spanExporter)))
{
var tracer = tracerFactory.GetTracer("stackdriver-test");
var tagContextBuilder = Tagger.CurrentBuilder.Put(FrontendKey, TagValue.Create("mobile-ios9.3.5"));
Stats.ViewManager.RegisterView(VideoSizeView);
using (tagContextBuilder.BuildScoped())
{
using (tracer.WithSpan(tracer.StartSpan("incoming request")))
{
tracer.CurrentSpan.AddEvent("Processing video.");
Thread.Sleep(TimeSpan.FromMilliseconds(10));
StatsRecorder.NewMeasureMap()
.Put(VideoSize, 25 * MiB)
.Record();
}
}
Thread.Sleep(TimeSpan.FromMilliseconds(5100));
var viewData = Stats.ViewManager.GetView(VideoSizeViewName);
Console.WriteLine(viewData);
Console.WriteLine("Done... wait for events to arrive to backend!");
Console.ReadLine();
metricExporter.Stop();
return(null);
}
}
public async Task <IEnumerable <MeteoriteLanding> > Get(int skip, int take)
{
var cacheKey = "meteorite-landings";
var tracer = TracerFactory.GetTracer("meteorites-controller-tracer");
using (tracer.StartActiveSpan("starts calling to gRPC service span", out var rootSpan))
{
var headers = new Metadata();
var outgoingSpan = tracer.StartSpan($"get meteorite-data span", rootSpan, SpanKind.Client);
if (outgoingSpan.Context.IsValid)
{
tracer.TextFormat.Inject(outgoingSpan.Context, headers, (headers, name, value) => headers.Add(name, value));
}
var result = await MeteoriteClient.GetMeteoriteLandingsAsync(
new MeteoriteLandingsRequest
{
Skip = skip,
Take = take
}, headers);
outgoingSpan.End();
var reply = result.MeteoriteLandings.ToList();
var returnData = new List <MeteoriteLanding>();
var getCacheSpan = tracer.StartSpan("get data from Redis Cache span", rootSpan);
var cacheResult = await RedisStore.RedisCache.StringGetAsync(cacheKey);
if (cacheResult.HasValue)
{
getCacheSpan.AddEvent("on get data from cache event");
returnData = JsonConvert.DeserializeObject <List <MeteoriteLanding> >(cacheResult.ToString());
}
getCacheSpan.End();
rootSpan.End();
return(returnData.Count <= 0 ? returnData : returnData.Skip(skip).Take(take));
}
}
public void ProxyTracer_UpdateTracer_StartRootSpanFrom_Kind_Timestamp_Links()
{
var proxyTracer = new ProxyTracer();
var realTracer = TracerFactory.Create(b => { }).GetTracer(null);
proxyTracer.UpdateTracer(realTracer);
var linkContext = new SpanContext(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom(), ActivityTraceFlags.Recorded);
var startTimestamp = DateTimeOffset.UtcNow.AddSeconds(-10);
var span = (SpanSdk)proxyTracer.StartRootSpan("foo", SpanKind.Server, new SpanCreationOptions
{
StartTimestamp = startTimestamp,
LinksFactory = () => new[] { new Link(linkContext) },
});
Assert.True(span.Context.IsValid);
Assert.Equal(span.Activity.TraceId, span.Context.TraceId);
Assert.Equal(span.Activity.SpanId, span.Context.SpanId);
Assert.Equal(default, span.ParentSpanId);
internal static object Run()
{
Console.WriteLine("Hello World!");
using var tracerFactory = TracerFactory.Create(builder => builder
.UseZipkin(o => o.ServiceName = "http-client-test")
.AddDependencyAdapter());
var tracer = tracerFactory.GetTracer("http-client-test");
using (tracer.StartActiveSpan("incoming request", out _))
{
using var client = new HttpClient();
client.GetStringAsync("http://bing.com").GetAwaiter().GetResult();
}
Console.ReadLine();
return(null);
}
public async Task Advise(MethodAsyncAdviceContext context)
{
using (var t = TracerFactory.StartTracer(context.TargetType, context.TargetMethod.Name))
{
if (info.ContainsCharacters())
{
t.SetAdidtionalInformation(info);
}
try
{
if (!context.IsTargetMethodAsync)
{
Task.Run(() => context.ProceedAsync()).Wait();
}
else
{
await context.ProceedAsync();
}
}
catch (AggregateException aex)
{
if (aex.InnerExceptions == null)
{
SetErrorInfo(t, aex.Flatten());
throw aex.Flatten();
}
;
if (aex.InnerExceptions.Count > 1)
{
SetErrorInfo(t, aex.Flatten());
throw aex.Flatten();
}
var ex = aex.InnerException;
SetErrorInfo(t, ex);
throw ex;
}
catch (Exception ex)
{
SetErrorInfo(t, ex);
throw;
}
}
}
protected void Application_Start()
{
this.tracerFactory = TracerFactory.Create(builder =>
{
builder
.UseJaeger(c =>
{
c.AgentHost = "localhost";
c.AgentPort = 6831;
})
.AddRequestAdapter()
.AddDependencyAdapter();
});
GlobalConfiguration.Configure(WebApiConfig.Register);
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
public void UseApplicationInsights_ConfiguresExporter()
{
var sentItems = new ConcurrentQueue <ITelemetry>();
ITelemetryChannel channel = new StubTelemetryChannel
{
OnSend = t => sentItems.Enqueue(t),
EndpointAddress = "http://foo",
};
var tracer = TracerFactory.Create(b => b
.SetProcessor(e => new SimpleSpanProcessor(e))
.UseApplicationInsights(o => o.TelemetryChannel = channel))
.GetTracer(null);
tracer.StartSpan("foo").End();
Assert.Single(sentItems);
}
/// <summary>add MagicOnion Telemetry.</summary>
public static IServiceCollection AddMagicOnionOpenTelemetry(this IServiceCollection services,
MagicOnionOpenTelemetryOptions options,
Action <MagicOnionOpenTelemetryOptions, MagicOnionOpenTelemetryMeterFactoryOption> configureMeterFactory,
Action <MagicOnionOpenTelemetryOptions, TracerBuilder> configureTracerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrEmpty(options.ServiceName))
{
throw new ArgumentNullException($"{nameof(options)}.{nameof(options.ServiceName)}");
}
services.AddSingleton(options);
// configure MeterFactory
if (configureMeterFactory != null)
{
var meterFactoryOption = new MagicOnionOpenTelemetryMeterFactoryOption();
configureMeterFactory(options, meterFactoryOption);
var meterFactory = MeterFactory.Create(mb =>
{
mb.SetMetricProcessor(meterFactoryOption.MetricProcessor);
mb.SetMetricExporter(meterFactoryOption.MetricExporter);
mb.SetMetricPushInterval(meterFactoryOption.MetricPushInterval);
});
services.AddSingleton(meterFactoryOption.MetricExporter);
services.AddSingleton(meterFactory);
}
// configure TracerFactory
if (configureTracerFactory != null)
{
var tracerFactory = TracerFactory.Create(tracerBuilder => configureTracerFactory(options, tracerBuilder));
services.AddSingleton(tracerFactory);
}
return(services);
}
public async void ProfilerSessionUsesTheSameDefault()
{
var spanProcessor = new Mock <SpanProcessor>(new NoopSpanExporter());
var tracer = TracerFactory.Create(b => b
.SetProcessor(_ => spanProcessor.Object))
.GetTracer(null);
using (var collector = new StackExchangeRedisCallsCollector(tracer))
{
var profilerFactory = collector.GetProfilerSessionsFactory();
var first = profilerFactory();
var second = profilerFactory();
ProfilingSession third = null;
await Task.Delay(1).ContinueWith((t) => { third = profilerFactory(); });
Assert.Equal(first, second);
Assert.Equal(second, third);
}
}
/// <summary>
/// Creates a tracer object for the child process, based on the command line arguments received from the parent process.
/// </summary>
/// <param name="args">The command line arguments.</param>
/// <returns>The tracer instance</returns>
public ITracer CreateTracerForChildProcess(string[] args)
{
ChildProcessArguments arguments = ChildProcessArguments.FromCommandLineArguments(args);
// Get sessionId from the arguments and create tracer
ITracer tracerForChildProcess = TracerFactory.Create(arguments.SessionId, null, true);
// Get custom dimensions from the arguments - do not override existing properties
IReadOnlyDictionary <string, string> existingProperties = tracerForChildProcess.GetCustomProperties();
foreach (var kv in arguments.CustomTracerProperties)
{
if (!existingProperties.ContainsKey(kv.Key))
{
tracerForChildProcess.AddCustomProperty(kv.Key, kv.Value);
}
}
return(tracerForChildProcess);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
// Obtain the API Key from the Web.Config file
var apiKey = ConfigurationManager.AppSettings["NewRelic.Telemetry.ApiKey"];
// Create the tracer factory registering New Relic as the Data Exporter
var tracerFactory = TracerFactory.Create((b) =>
{
b.UseNewRelic(apiKey)
.AddDependencyCollector()
.SetSampler(Samplers.AlwaysSample);
});
var dependenciesCollector = new DependenciesCollector(new HttpClientCollectorOptions(), tracerFactory);
// Make the tracer available to the application
OTTracer = tracerFactory.GetTracer("SampleAspNetFrameworkApp");
}
public void FactoryReturnsSameTracerForGivenNameAndVersion()
{
var tracerFactory = TracerFactory.Create(b => { });
var tracer1 = tracerFactory.GetTracer("foo", "semver:1.2.3");
var tracer2 = tracerFactory.GetTracer("foo");
var tracer3 = tracerFactory.GetTracer("foo", "semver:2.3.4");
var tracer4 = tracerFactory.GetTracer("bar", "semver:1.2.3");
var tracer5 = tracerFactory.GetTracer("foo", "semver:1.2.3");
var tracer6 = tracerFactory.GetTracer(string.Empty);
var tracer7 = tracerFactory.GetTracer(null);
var tracer8 = tracerFactory.GetTracer(null, "semver:1.2.3");
Assert.NotEqual(tracer1, tracer2);
Assert.NotEqual(tracer1, tracer3);
Assert.NotEqual(tracer1, tracer4);
Assert.Equal(tracer1, tracer5);
Assert.NotEqual(tracer5, tracer6);
Assert.Equal(tracer6, tracer7);
Assert.Equal(tracer7, tracer8);
}
public bool TryUpdateCache(string configSet, string environment)
{
using (TracerFactory.StartTracer(this, "TryUpdateCache"))
{
var config = configSetTask.GetConfigSet(configSet);
bool doSave;
var raw = config.GetRawConfigData(environment, out doSave);
var environmentSettings = GetEnvironmentSettings(config, environment);
if (doSave)
{
environmentTask.UpdateEnvironment(environmentSettings);
}
if (realtimeNotificationService != null)
{
realtimeNotificationService(configSet, environment);
}
var wrapper = Runtime.CreateRuntimeTask <ICacheManagementWrapper>(environmentSettings.CacheType.CacheType);
return(wrapper.UpdateCache(environmentSettings, raw));
}
}
internal static object Run()
{
var metricExporter = new ApplicationInsightsMetricExporter(Stats.ViewManager, new TelemetryConfiguration("instrumentation-key"));
metricExporter.Start();
var tagContextBuilder = Tagger.CurrentBuilder.Put(FrontendKey, TagValue.Create("mobile-ios9.3.5"));
using (var tracerFactory = TracerFactory.Create(builder => builder
.UseApplicationInsights(config => config.InstrumentationKey = "instrumentation-key")))
{
var tracer = tracerFactory.GetTracer("application-insights-test");
var span = tracer.StartSpan("incoming request");
Stats.ViewManager.RegisterView(VideoSizeView);
using (tagContextBuilder.BuildScoped())
{
using (tracer.WithSpan(span))
{
tracer.CurrentSpan.AddEvent("Start processing video.");
Thread.Sleep(TimeSpan.FromMilliseconds(10));
StatsRecorder.NewMeasureMap().Put(VideoSize, 25 * MiB).Record();
tracer.CurrentSpan.AddEvent("Finished processing video.");
}
}
Thread.Sleep(TimeSpan.FromMilliseconds(5100));
var viewData = Stats.ViewManager.GetView(VideoSizeViewName);
Console.WriteLine(viewData);
Console.WriteLine("Done... wait for events to arrive to backend!");
Console.ReadLine();
metricExporter.Stop();
return(null);
}
}
public async Task SuccessfulTemplateControllerCallUsesParentContext()
{
var spanProcessor = new Mock <SpanProcessor>();
var expectedTraceId = ActivityTraceId.CreateRandom();
var expectedSpanId = ActivitySpanId.CreateRandom();
// Arrange
using (var testFactory = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(services =>
{
services.AddSingleton <TracerFactory>(_ =>
TracerFactory.Create(b => b
.AddProcessorPipeline(p => p.AddProcessor(n => spanProcessor.Object))
.AddRequestCollector()));
})))
using (var client = testFactory.CreateClient())
{
var request = new HttpRequestMessage(HttpMethod.Get, "/api/values/2");
request.Headers.Add("traceparent", $"00-{expectedTraceId}-{expectedSpanId}-01");
// Act
var response = await client.SendAsync(request);
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
WaitForProcessorInvocations(spanProcessor, 2);
}
Assert.Equal(2, spanProcessor.Invocations.Count); // begin and end was called
var span = (SpanData)spanProcessor.Invocations[1].Arguments[0];
Assert.Equal(SpanKind.Server, span.Kind);
Assert.Equal("api/Values/{id}", span.Name);
Assert.Equal("/api/values/2", span.Attributes.GetValue("http.path"));
Assert.Equal(expectedTraceId, span.Context.TraceId);
Assert.Equal(expectedSpanId, span.ParentSpanId);
}
public async Task SuccessfulTemplateControllerCallGeneratesASpan()
{
var spanProcessor = new Mock <SpanProcessor>(new NoopSpanExporter());
var tracerFactory = new TracerFactory(spanProcessor.Object);
void ConfigureTestServices(IServiceCollection services) =>
services.AddSingleton <ITracerFactory>(tracerFactory);
// Arrange
using (var client = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(ConfigureTestServices))
.CreateClient())
{
// Act
var response = await client.GetAsync("/api/values");
// Assert
response.EnsureSuccessStatusCode(); // Status Code 200-299
for (var i = 0; i < 10; i++)
{
if (spanProcessor.Invocations.Count == 2)
{
break;
}
// We need to let End callback execute as it is executed AFTER response was returned.
// In unit tests environment there may be a lot of parallel unit tests executed, so
// giving some breezing room for the End callback to complete
await Task.Delay(TimeSpan.FromSeconds(1));
}
}
Assert.Equal(2, spanProcessor.Invocations.Count); // begin and end was called
var span = ((Span)spanProcessor.Invocations[1].Arguments[0]);
Assert.Equal(SpanKind.Server, span.Kind);
Assert.Equal("/api/values", span.Attributes.GetValue("http.path"));
}
public void SimpleTraceTest()
{
ITracer tracer;
using (tracer = TracerFactory.StartTracer(this, "Test", "Test"))
{
using (TracerFactory.StartTracer(this, "Inner1", "test"))
{
var item = new InnerTracerTest();
item.SomeMethod();
}
using (TracerFactory.StartTracer(this, "Inner2", "test"))
{
var item = new InnerTracerTest();
item.SomeMethod();
}
Assert.IsNull(tracer.ParentItem);
Assert.IsNotNull(tracer.GetCallstack());
Assert.IsNotNull(tracer.GetCallstack().CallStack.FirstOrDefault());
}
}
/// <summary>
/// Implements advice logic.
/// Usually, advice must invoke context.Proceed()
/// </summary>
/// <param name="context">The method advice context.</param>
public void Advise(MethodAdviceContext context)
{
using (var t = TracerFactory.StartTracer(context.TargetType, context.TargetMethod.Name))
{
try
{
context.Proceed();
}
catch (Exception ex)
{
if (TreatExceptionAsInformational)
{
t.SetException(ex);
}
else
{
t.SetErrorState(ex);
}
}
}
}
