internal static object Run(OpenTelemetryShimOptions options)
{
// Enable OpenTelemetry for the source "MyCompany.MyProduct.MyWebServer"
// and use a single pipeline with a custom MyProcessor, and Console exporter.
using var tracerProvider = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("MyCompany.MyProduct.MyWebServer")
.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("MyServiceName"))
.AddConsoleExporter()
.Build();
// The above line is required only in applications
// which decide to use OpenTelemetry.
var tracer = TracerProvider.Default.GetTracer("MyCompany.MyProduct.MyWebServer");
using (var parentSpan = tracer.StartActiveSpan("parent span"))
{
parentSpan.SetAttribute("mystring", "value");
parentSpan.SetAttribute("myint", 100);
parentSpan.SetAttribute("mydouble", 101.089);
parentSpan.SetAttribute("mybool", true);
parentSpan.UpdateName("parent span new name");
var childSpan = tracer.StartSpan("child span");
childSpan.AddEvent("sample event").SetAttribute("ch", "value").SetAttribute("more", "attributes");
childSpan.SetStatus(Status.Ok);
childSpan.End();
}
System.Console.WriteLine("Press Enter key to exit.");
return(null);
}
public async Task HttpWebRequestInstrumentationInjectsHeadersAsync()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using var shutdownSignal = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddHttpClientInstrumentation()
.Build();
var request = (HttpWebRequest)WebRequest.Create(this.url);
request.Method = "GET";
var parent = new Activity("parent")
.SetIdFormat(ActivityIdFormat.W3C)
.Start();
parent.TraceStateString = "k1=v1,k2=v2";
parent.ActivityTraceFlags = ActivityTraceFlags.Recorded;
using var response = await request.GetResponseAsync();
Assert.Equal(3, activityProcessor.Invocations.Count); // SetParentProvider/Begin/End called
var activity = (Activity)activityProcessor.Invocations[2].Arguments[0];
Assert.Equal(parent.TraceId, activity.Context.TraceId);
Assert.Equal(parent.SpanId, activity.ParentSpanId);
Assert.NotEqual(parent.SpanId, activity.Context.SpanId);
Assert.NotEqual(default, activity.Context.SpanId);
private static object RunWithActivitySource()
{
// Enable OpenTelemetry for the sources "Samples.SampleServer" and "Samples.SampleClient"
// and use Console exporter.
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("Samples.SampleClient", "Samples.SampleServer")
.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("console-test"))
.AddProcessor(new MyProcessor()) // This must be added before ConsoleExporter
.AddConsoleExporter()
.Build();
// The above line is required only in applications
// which decide to use OpenTelemetry.
using (var sample = new InstrumentationWithActivitySource())
{
sample.Start();
System.Console.WriteLine("Traces are being created and exported " +
"to Console in the background. " +
"Press ENTER to stop.");
System.Console.ReadLine();
}
return(null);
}
public void SetErrorStatusOnExceptionDisabled()
{
using var activitySource = new ActivitySource(ActivitySourceName);
using var tracerProvider = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.SetSampler(new AlwaysOnSampler())
.SetErrorStatusOnException()
.SetErrorStatusOnException(false)
.Build();
Activity activity = null;
try
{
using (activity = activitySource.StartActivity("Activity"))
{
throw new Exception("Oops!");
}
}
catch (Exception)
{
}
Assert.Equal(StatusCode.Unset, activity.GetStatus().StatusCode);
}
public void TracerSdkSetsActivityDataRequestedToFalseWhenSuppressInstrumentationIsTrueForLegacyActivity()
{
using TestActivityProcessor testActivityProcessor = new TestActivityProcessor();
bool startCalled = false;
bool endCalled = false;
testActivityProcessor.StartAction =
(a) =>
{
startCalled = true;
};
testActivityProcessor.EndAction =
(a) =>
{
endCalled = true;
};
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddLegacySource("random")
.AddProcessor(testActivityProcessor)
.SetSampler(new AlwaysOnSampler())
.Build();
using (SuppressInstrumentationScope.Begin(true))
{
using var activity = new Activity("random").Start();
Assert.False(activity.IsAllDataRequested);
}
Assert.False(startCalled);
Assert.False(endCalled);
}
public void EnumerateLinksNonempty()
{
using var openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.Build();
var links = new[]
public void GetCurrentSpanBlank()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
Assert.False(Tracer.CurrentSpan.Context.IsValid);
}
public void Tracer_StartActiveSpan_CreatesActiveSpan()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
var span1 = this.tracer.StartActiveSpan("Test");
Assert.Equal(span1.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
var span2 = this.tracer.StartActiveSpan("Test", SpanKind.Client);
Assert.Equal(span2.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
var span = this.tracer.StartSpan("foo");
Tracer.WithSpan(span);
var span3 = this.tracer.StartActiveSpan("Test", SpanKind.Client, span);
Assert.Equal(span3.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
var spanContext = new SpanContext(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom(), ActivityTraceFlags.Recorded);
var span4 = this.tracer.StartActiveSpan("Test", SpanKind.Client, spanContext);
Assert.Equal(span4.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
}
public void ExportResultIsSuccess()
{
#if NETCOREAPP3_1
// Adding the OtlpExporter creates a GrpcChannel.
// This switch must be set before creating a GrpcChannel/HttpClient when calling an insecure gRPC service.
// See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
#endif
var exporterOptions = new OtlpExporterOptions
{
Endpoint = new System.Uri($"http://{CollectorEndpoint}"),
};
var otlpExporter = new OtlpTraceExporter(exporterOptions);
var delegatingExporter = new DelegatingTestExporter <Activity>(otlpExporter);
var exportActivityProcessor = new SimpleActivityExportProcessor(delegatingExporter);
var activitySourceName = "otlp.collector.test";
var builder = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(activitySourceName)
.AddProcessor(exportActivityProcessor);
using var tracerProvider = builder.Build();
var source = new ActivitySource(activitySourceName);
var activity = source.StartActivity("Test Activity");
activity?.Stop();
Assert.Single(delegatingExporter.ExportResults);
Assert.Equal(ExportResult.Success, delegatingExporter.ExportResults[0]);
}
public TraceShimBenchmarks()
{
Activity.DefaultIdFormat = ActivityIdFormat.W3C;
OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddSource("Benchmark.OneProcessor")
.AddProcessor(new DummyActivityProcessor())
.Build();
OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddSource("Benchmark.TwoProcessors")
.AddProcessor(new DummyActivityProcessor())
.AddProcessor(new DummyActivityProcessor())
.Build();
OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddSource("Benchmark.ThreeProcessors")
.AddProcessor(new DummyActivityProcessor())
.AddProcessor(new DummyActivityProcessor())
.AddProcessor(new DummyActivityProcessor())
.Build();
}
internal static object Run(string zipkinUri)
{
// Prerequisite for running this example.
// Setup zipkin inside local docker using following command:
// docker run -d -p 9411:9411 openzipkin/zipkin
// To run this example, run the following command from
// the reporoot\examples\Console\.
// (eg: C:\repos\opentelemetry-dotnet\examples\Console\)
//
// dotnet run zipkin -u http://localhost:9411/api/v2/spans
// Enable OpenTelemetry for the sources "Samples.SampleServer" and "Samples.SampleClient"
// and use the Zipkin exporter.
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("Samples.SampleClient", "Samples.SampleServer")
.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("zipkin-test"))
.AddZipkinExporter(o =>
{
o.Endpoint = new Uri(zipkinUri);
})
.Build();
using (var sample = new InstrumentationWithActivitySource())
{
sample.Start();
System.Console.WriteLine("Traces are being created and exported" +
"to Zipkin in the background. Use Zipkin to view them. " +
"Press ENTER to stop.");
System.Console.ReadLine();
}
return(null);
}
public void TracerProviderSdkSamplerAttributesAreAppliedToActivity(SamplingDecision sampling)
{
var testSampler = new TestSampler();
testSampler.SamplingAction = (samplingParams) =>
{
var attributes = new Dictionary <string, object>();
attributes.Add("tagkeybysampler", "tagvalueaddedbysampler");
return(new SamplingResult(sampling, attributes));
};
using var activitySource = new ActivitySource(ActivitySourceName);
using var sdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.SetSampler(testSampler)
.Build();
using (var rootActivity = activitySource.StartActivity("root"))
{
Assert.NotNull(rootActivity);
Assert.Equal(rootActivity.TraceId, testSampler.LatestSamplingParameters.TraceId);
if (sampling != SamplingDecision.Drop)
{
Assert.Contains(new KeyValuePair <string, object>("tagkeybysampler", "tagvalueaddedbysampler"), rootActivity.TagObjects);
}
}
}
public void SdkSamplesAndProcessesLegacyActivityWithRightConfigOnWildCardMode()
{
bool samplerCalled = false;
var sampler = new TestSampler
{
SamplingAction =
(samplingParameters) =>
{
samplerCalled = true;
return(new SamplingResult(SamplingDecision.RecordAndSample));
},
};
using TestActivityProcessor testActivityProcessor = new TestActivityProcessor();
bool startCalled = false;
bool endCalled = false;
testActivityProcessor.StartAction =
(a) =>
{
Assert.True(samplerCalled);
Assert.False(OpenTelemetrySdk.SuppressInstrumentation);
Assert.True(a.IsAllDataRequested); // If Proccessor.OnStart is called, activity's IsAllDataRequested is set to true
startCalled = true;
};
testActivityProcessor.EndAction =
(a) =>
{
Assert.False(OpenTelemetrySdk.SuppressInstrumentation);
Assert.True(a.IsAllDataRequested); // If Processor.OnEnd is called, activity's IsAllDataRequested is set to true
endCalled = true;
};
var emptyActivitySource = new ActivitySource(string.Empty);
Assert.False(emptyActivitySource.HasListeners()); // No ActivityListener for empty ActivitySource added yet
var operationNameForLegacyActivity = "TestOperationName";
// AddLegacyOperationName chained to TracerProviderBuilder
using var tracerProvider = OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(sampler)
.AddSource("ABCCompany.XYZProduct.*") // Adding a wild card source
.AddProcessor(testActivityProcessor)
.AddLegacySource(operationNameForLegacyActivity)
.Build();
Assert.True(emptyActivitySource.HasListeners()); // Listener for empty ActivitySource added after TracerProvider build
Activity activity = new Activity(operationNameForLegacyActivity);
activity.Start();
activity.Stop();
Assert.True(startCalled); // Processor.OnStart is called since we added a legacy OperationName
Assert.True(endCalled); // Processor.OnEnd is called since we added a legacy OperationName
}
private static object RunWithActivitySource(string endpoint)
{
// Adding the OtlpExporter creates a GrpcChannel.
// This switch must be set before creating a GrpcChannel/HttpClient when calling an insecure gRPC service.
// See: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot#call-insecure-grpc-services-with-net-core-client
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
// Enable OpenTelemetry for the sources "Samples.SampleServer" and "Samples.SampleClient"
// and use OTLP exporter.
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("Samples.SampleClient", "Samples.SampleServer")
.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("otlp-test"))
.AddOtlpExporter(opt => opt.Endpoint = new Uri(endpoint))
.Build();
// The above line is required only in Applications
// which decide to use OpenTelemetry.
using (var sample = new InstrumentationWithActivitySource())
{
sample.Start();
System.Console.WriteLine("Traces are being created and exported" +
"to the OpenTelemetry Collector in the background. " +
"Press ENTER to stop.");
System.Console.ReadLine();
}
return(null);
}
public async Task RequestNotCollectedWhenFilterThrowException()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
void ConfigureTestServices(IServiceCollection services)
{
this.openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddAspNetCoreInstrumentation((opt) => opt.Filter = (ctx) =>
{
if (ctx.Request.Path == "/api/values/2")
{
throw new Exception("from InstrumentationFilter");
}
else
{
return(true);
}
})
.AddProcessor(activityProcessor.Object)
.Build();
}
// Arrange
using (var testFactory = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(ConfigureTestServices)))
{
using var client = testFactory.CreateClient();
// Act
using (var inMemoryEventListener = new InMemoryEventListener(AspNetCoreInstrumentationEventSource.Log))
{
var response1 = await client.GetAsync("/api/values");
var response2 = await client.GetAsync("/api/values/2");
response1.EnsureSuccessStatusCode(); // Status Code 200-299
response2.EnsureSuccessStatusCode(); // Status Code 200-299
Assert.Single(inMemoryEventListener.Events.Where((e) => e.EventId == 3));
}
WaitForProcessorInvocations(activityProcessor, 3);
}
// As InstrumentationFilter threw, we continue as if the
// InstrumentationFilter did not exist.
// List of invocations on the processor
// 1. SetParentProvider for TracerProviderSdk
// 2. OnStart for the activity created by AspNetCore for "/api/values" with the OperationName: Microsoft.AspNetCore.Hosting.HttpRequestIn
// 3. OnEnd for the activity created by AspNetCore for "/api/values" with the OperationName: Microsoft.AspNetCore.Hosting.HttpRequestIn
// 4. OnStart for the activity created by AspNetCore for "/api/values/2" with the OperationName: Microsoft.AspNetCore.Hosting.HttpRequestIn
// we should only call Processor.OnEnd for the "/api/values" request
Assert.Single(activityProcessor.Invocations, invo => invo.Method.Name == "OnEnd");
var activity = activityProcessor.Invocations.FirstOrDefault(invo => invo.Method.Name == "OnEnd").Arguments[0] as Activity;
ValidateAspNetCoreActivity(activity, "/api/values");
}
public void SqlClientErrorsAreCollectedSuccessfully(string beforeCommand, string errorCommand, bool shouldEnrich = true, bool recordException = false)
{
using var sqlConnection = new SqlConnection(TestConnectionString);
using var sqlCommand = sqlConnection.CreateCommand();
var processor = new Mock <BaseProcessor <Activity> >();
using (OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSqlClientInstrumentation(options =>
{
options.RecordException = recordException;
if (shouldEnrich)
{
options.Enrich = ActivityEnrichment;
}
})
.AddProcessor(processor.Object)
.Build())
{
var operationId = Guid.NewGuid();
sqlCommand.CommandText = "SP_GetOrders";
sqlCommand.CommandType = CommandType.StoredProcedure;
var beforeExecuteEventData = new
{
OperationId = operationId,
Command = sqlCommand,
Timestamp = (long?)1000000L,
};
this.fakeSqlClientDiagnosticSource.Write(
beforeCommand,
beforeExecuteEventData);
var commandErrorEventData = new
{
OperationId = operationId,
Command = sqlCommand,
Exception = new Exception("Boom!"),
Timestamp = 2000000L,
};
this.fakeSqlClientDiagnosticSource.Write(
errorCommand,
commandErrorEventData);
}
Assert.Equal(5, processor.Invocations.Count); // SetParentProvider/OnStart/OnEnd/OnShutdown/Dispose called.
VerifyActivityData(
sqlCommand.CommandType,
sqlCommand.CommandText,
true,
false,
true,
recordException,
sqlConnection.DataSource,
(Activity)processor.Invocations[2].Arguments[0]);
}
public async Task ExtractContextIrrespectiveOfSamplingDecision(SamplingDecision samplingDecision)
{
try
{
var expectedTraceId = ActivityTraceId.CreateRandom();
var expectedParentSpanId = ActivitySpanId.CreateRandom();
var expectedTraceState = "rojo=1,congo=2";
var activityContext = new ActivityContext(expectedTraceId, expectedParentSpanId, ActivityTraceFlags.Recorded, expectedTraceState);
var expectedBaggage = Baggage.SetBaggage("key1", "value1").SetBaggage("key2", "value2");
OpenTelemetrySdk.SetDefaultTextMapPropagator(new ExtractOnlyPropagator(activityContext, expectedBaggage));
// Arrange
using (var testFactory = this.factory
.WithWebHostBuilder(builder =>
builder.ConfigureTestServices(services =>
{
this.openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(new TestSampler(samplingDecision))
.AddAspNetCoreInstrumentation()
.Build();
})))
{
using var client = testFactory.CreateClient();
// Test TraceContext Propagation
var request = new HttpRequestMessage(HttpMethod.Get, "/api/GetChildActivityTraceContext");
var response = await client.SendAsync(request);
var childActivityTraceContext = JsonConvert.DeserializeObject <Dictionary <string, string> >(response.Content.ReadAsStringAsync().Result);
response.EnsureSuccessStatusCode();
Assert.Equal(expectedTraceId.ToString(), childActivityTraceContext["TraceId"]);
Assert.Equal(expectedTraceState, childActivityTraceContext["TraceState"]);
Assert.NotEqual(expectedParentSpanId.ToString(), childActivityTraceContext["ParentSpanId"]); // there is a new activity created in instrumentation therefore the ParentSpanId is different that what is provided in the headers
// Test Baggage Context Propagation
request = new HttpRequestMessage(HttpMethod.Get, "/api/GetChildActivityBaggageContext");
response = await client.SendAsync(request);
var childActivityBaggageContext = JsonConvert.DeserializeObject <IReadOnlyDictionary <string, string> >(response.Content.ReadAsStringAsync().Result);
response.EnsureSuccessStatusCode();
Assert.Single(childActivityBaggageContext, item => item.Key == "key1" && item.Value == "value1");
Assert.Single(childActivityBaggageContext, item => item.Key == "key2" && item.Value == "value2");
}
}
finally
{
OpenTelemetrySdk.SetDefaultTextMapPropagator(new CompositeTextMapPropagator(new TextMapPropagator[]
{
new TraceContextPropagator(),
new BaggagePropagator(),
}));
}
}
public void TracerSdkSetsActivitySamplingResultBasedOnSamplingDecision()
{
var testSampler = new TestSampler();
using var activitySource = new ActivitySource(ActivitySourceName);
using var sdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.SetSampler(testSampler)
.Build();
testSampler.SamplingAction = (samplingParameters) =>
{
return(new SamplingResult(SamplingDecision.RecordAndSample));
};
using (var activity = activitySource.StartActivity("root"))
{
Assert.NotNull(activity);
Assert.True(activity.IsAllDataRequested);
Assert.True(activity.Recorded);
}
testSampler.SamplingAction = (samplingParameters) =>
{
return(new SamplingResult(SamplingDecision.RecordOnly));
};
using (var activity = activitySource.StartActivity("root"))
{
// Even if sampling returns false, for root activities,
// activity is still created with PropagationOnly.
Assert.NotNull(activity);
Assert.True(activity.IsAllDataRequested);
Assert.False(activity.Recorded);
}
testSampler.SamplingAction = (samplingParameters) =>
{
return(new SamplingResult(SamplingDecision.Drop));
};
using (var activity = activitySource.StartActivity("root"))
{
// Even if sampling returns false, for root activities,
// activity is still created with PropagationOnly.
Assert.NotNull(activity);
Assert.False(activity.IsAllDataRequested);
Assert.False(activity.Recorded);
using (var innerActivity = activitySource.StartActivity("inner"))
{
// This is not a root activity.
// If sampling returns false, no activity is created at all.
Assert.Null(innerActivity);
}
}
}
public void CreateSpan_Sampled()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
var span = this.tracer.StartSpan("foo");
Assert.True(span.IsRecording);
}
public void GetCurrentSpanBlankWontThrowOnEnd()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
var current = Tracer.CurrentSpan;
current.End();
}
public async Task HttpClientInstrumentationInjectsHeadersAsync(bool shouldEnrich)
{
var processor = new Mock <BaseProcessor <Activity> >();
var request = new HttpRequestMessage
{
RequestUri = new Uri(this.url),
Method = new HttpMethod("GET"),
};
var parent = new Activity("parent")
.SetIdFormat(ActivityIdFormat.W3C)
.Start();
parent.TraceStateString = "k1=v1,k2=v2";
parent.ActivityTraceFlags = ActivityTraceFlags.Recorded;
// var isInjectedHeaderValueGetterThrows = false;
// mockTextFormat
// .Setup(x => x.IsInjected(It.IsAny<HttpRequestMessage>(), It.IsAny<Func<HttpRequestMessage, string, IEnumerable<string>>>()))
// .Callback<HttpRequestMessage, Func<HttpRequestMessage, string, IEnumerable<string>>>(
// (carrier, getter) =>
// {
// try
// {
// // traceparent doesn't exist
// getter(carrier, "traceparent");
// }
// catch
// {
// isInjectedHeaderValueGetterThrows = true;
// }
// });
using (OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddHttpClientInstrumentation(o =>
{
if (shouldEnrich)
{
o.Enrich = ActivityEnrichment;
}
})
.AddProcessor(processor.Object)
.Build())
{
using var c = new HttpClient();
await c.SendAsync(request);
}
Assert.Equal(5, processor.Invocations.Count); // SetParentProvider/OnStart/OnEnd/OnShutdown/Dispose called.
var activity = (Activity)processor.Invocations[2].Arguments[0];
Assert.Equal(ActivityKind.Client, activity.Kind);
Assert.Equal(parent.TraceId, activity.Context.TraceId);
Assert.Equal(parent.SpanId, activity.ParentSpanId);
Assert.NotEqual(parent.SpanId, activity.Context.SpanId);
Assert.NotEqual(default, activity.Context.SpanId);
public void GetStatusWithNoStatusInActivity()
{
using var openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.Build();
using var source = new ActivitySource(ActivitySourceName);
using var activity = source.StartActivity(ActivityName);
activity?.Stop();
Assert.Equal(Status.Unset, activity.GetStatus());
}
public void GetCurrentSpan()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
var span = this.tracer.StartSpan("foo");
Tracer.WithSpan(span);
Assert.Equal(span.Context.SpanId, Tracer.CurrentSpan.Context.SpanId);
Assert.True(Tracer.CurrentSpan.Context.IsValid);
}
public void SetCancelledStatus()
{
using var openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.Build();
using var source = new ActivitySource(ActivitySourceName);
using var activity = source.StartActivity(ActivityName);
activity.SetStatus(Status.Error);
activity?.Stop();
Assert.True(activity.GetStatus().StatusCode.Equals(Status.Error.StatusCode));
}
public void Tracer_StartActiveSpan_FromParent_BadArgs_NullSpanName()
{
using var openTelemetry = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource("tracername")
.Build();
var span1 = this.tracer.StartActiveSpan(null, SpanKind.Client, TelemetrySpan.NoopInstance);
Assert.Null(span1.Activity.DisplayName);
var span2 = this.tracer.StartActiveSpan(null, SpanKind.Client, TelemetrySpan.NoopInstance, default);
Assert.Null(span2.Activity.DisplayName);
}
public void StackExchangeRedis_BadArgs()
{
TracerProviderBuilder builder = null;
Assert.Throws <ArgumentNullException>(() => builder.AddRedisInstrumentation(null));
var activityProcessor = new Mock <BaseProcessor <Activity> >();
Assert.Throws <ArgumentNullException>(() =>
OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddRedisInstrumentation(null)
.Build());
}
public void LastSetStatusWins()
{
using var openTelemetrySdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(ActivitySourceName)
.Build();
using var source = new ActivitySource(ActivitySourceName);
using var activity = source.StartActivity(ActivityName);
activity.SetStatus(Status.Error);
activity.SetStatus(Status.Ok);
activity?.Stop();
Assert.Equal(Status.Ok, activity.GetStatus());
}
public RedisProfilerEntryToActivityConverterTests()
{
var connectionOptions = new ConfigurationOptions
{
AbortOnConnectFail = false,
};
connectionOptions.EndPoints.Add("localhost:6379");
this.connection = ConnectionMultiplexer.Connect(connectionOptions);
this.sdk = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddRedisInstrumentation(this.connection)
.Build();
}
public static void Main()
{
using var tracerProvider = OpenTelemetrySdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddSource("MyCompany.MyProduct.MyLibrary")
.AddConsoleExporter()
.Build();
using (var activity = MyActivitySource.StartActivity("SayHello"))
{
activity?.SetTag("foo", 1);
activity?.SetTag("bar", "Hello, World!");
activity?.SetTag("baz", new int[] { 1, 2, 3 });
}
}
public void SdkProcessesLegacyActivityWhenActivitySourceIsUpdatedWithAddSource()
{
using TestActivityProcessor testActivityProcessor = new TestActivityProcessor();
bool startCalled = false;
bool endCalled = false;
testActivityProcessor.StartAction =
(a) =>
{
Assert.False(OpenTelemetrySdk.SuppressInstrumentation);
Assert.True(a.IsAllDataRequested); // If Proccessor.OnStart is called, activity's IsAllDataRequested is set to true
startCalled = true;
};
testActivityProcessor.EndAction =
(a) =>
{
Assert.False(OpenTelemetrySdk.SuppressInstrumentation);
Assert.True(a.IsAllDataRequested); // If Processor.OnEnd is called, activity's IsAllDataRequested is set to true
endCalled = true;
};
var emptyActivitySource = new ActivitySource(string.Empty);
Assert.False(emptyActivitySource.HasListeners()); // No ActivityListener for empty ActivitySource added yet
var operationNameForLegacyActivity = "TestOperationName";
var activitySourceForLegacyActvity = new ActivitySource("TestActivitySource", "1.0.0");
// AddLegacyOperationName chained to TracerProviderBuilder
using var tracerProvider = OpenTelemetrySdk.CreateTracerProviderBuilder()
.AddSource(activitySourceForLegacyActvity.Name) // Add the updated ActivitySource as a Source
.AddLegacySource(operationNameForLegacyActivity)
.AddProcessor(testActivityProcessor)
.Build();
Assert.True(emptyActivitySource.HasListeners()); // Listener for empty ActivitySource added after TracerProvider build
Activity activity = new Activity(operationNameForLegacyActivity);
activity.Start();
ActivityInstrumentationHelper.SetActivitySourceProperty(activity, activitySourceForLegacyActvity);
activity.Stop();
Assert.True(startCalled); // Processor.OnStart is called since we provided the legacy OperationName
Assert.True(endCalled); // Processor.OnEnd is not called since the ActivitySource is updated and the updated source name is added as a Source to the provider
}