public void TracingDisabled_DoesNotSubmitsTraces(InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
ConfigureInstrumentation(instrumentation, enableSocketsHandler);
const string expectedOperationName = "http.request";
using var telemetry = this.ConfigureTelemetry();
int httpPort = TcpPortProvider.GetOpenPort();
using (var agent = EnvironmentHelper.GetMockAgent())
using (ProcessResult processResult = RunSampleAndWaitForExit(agent, arguments: $"TracingDisabled Port={httpPort}"))
{
var spans = agent.WaitForSpans(1, 2000, operationName: expectedOperationName);
Assert.Equal(0, spans.Count);
var traceId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TraceId);
var parentSpanId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.ParentId);
var tracingEnabled = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TracingEnabled);
Assert.Null(traceId);
Assert.Null(parentSpanId);
Assert.Equal("false", tracingEnabled);
using var scope = new AssertionScope();
// ignore auto enabled for simplicity
telemetry.AssertIntegrationDisabled(IntegrationId.HttpMessageHandler);
telemetry.AssertIntegration(IntegrationId.HttpSocketsHandler, enabled: false, autoEnabled: null);
telemetry.AssertIntegration(IntegrationId.WinHttpHandler, enabled: false, autoEnabled: null);
telemetry.AssertIntegration(IntegrationId.CurlHandler, enabled: false, autoEnabled: null);
}
}
private static int CalculateExpectedAsyncSpans(InstrumentationOptions instrumentation, bool enableCallTarget)
{
var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
// net4x doesn't have patch
var spansPerHttpClient = EnvironmentHelper.IsCoreClr() ? 35 : 31;
var expectedSpanCount = spansPerHttpClient * 2; // default HttpClient and CustomHttpClientHandler
#if !NET452
// WinHttpHandler instrumentation is off by default, and only available on Windows
if (enableCallTarget && isWindows && (instrumentation.InstrumentWinHttpOrCurlHandler ?? false))
{
expectedSpanCount += spansPerHttpClient;
}
#endif
// SocketsHttpHandler instrumentation is on by default
if (EnvironmentHelper.IsCoreClr() && (instrumentation.InstrumentSocketHandler ?? true))
{
expectedSpanCount += spansPerHttpClient;
}
#if NETCOREAPP2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
if (enableCallTarget && instrumentation.InstrumentWinHttpOrCurlHandler == true)
{
// Add 1 span for internal WinHttpHandler and CurlHandler using the HttpMessageInvoker
expectedSpanCount++;
}
#endif
return(expectedSpanCount);
}
private static int CalculateExpectedAsyncSpans(InstrumentationOptions instrumentation)
{
// net4x doesn't have patch
var spansPerHttpClient = EnvironmentHelper.IsCoreClr() ? 35 : 31;
var expectedSpanCount = spansPerHttpClient * 2; // default HttpClient and CustomHttpClientHandler
if (IsUsingWinHttpHandler(instrumentation))
{
expectedSpanCount += spansPerHttpClient;
}
if (IsUsingSocketHandler(instrumentation))
{
expectedSpanCount += spansPerHttpClient;
}
#if NETCOREAPP2_1 || NETCOREAPP3_0 || NETCOREAPP3_1
if (instrumentation.InstrumentWinHttpOrCurlHandler == true)
{
// Add 1 span for internal WinHttpHandler and CurlHandler using the HttpMessageInvoker
expectedSpanCount++;
}
#endif
return(expectedSpanCount);
}
public void TracingDisabled_DoesNotSubmitsTraces(bool enableCallTarget, InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
ConfigureInstrumentation(enableCallTarget, instrumentation, enableSocketsHandler);
const string expectedOperationName = "http.request";
int agentPort = TcpPortProvider.GetOpenPort();
int httpPort = TcpPortProvider.GetOpenPort();
using (var agent = new MockTracerAgent(agentPort))
using (ProcessResult processResult = RunSampleAndWaitForExit(agent.Port, arguments: $"TracingDisabled Port={httpPort}"))
{
Assert.True(processResult.ExitCode >= 0, $"Process exited with code {processResult.ExitCode}");
var spans = agent.WaitForSpans(1, 2000, operationName: expectedOperationName);
Assert.Equal(0, spans.Count);
var traceId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TraceId);
var parentSpanId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.ParentId);
var tracingEnabled = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TracingEnabled);
Assert.Null(traceId);
Assert.Null(parentSpanId);
Assert.Equal("false", tracingEnabled);
}
}
public void InstrumentSampleProject()
{
if (Directory.Exists(OutputPath))
{
CleanDirectory(OutputPath);
}
else
{
Directory.CreateDirectory(OutputPath);
}
var oridgAssemblyFileName = typeof(PrimeCalculator).Assembly.Location;
var origPdbFileName = Path.ChangeExtension(oridgAssemblyFileName, "pdb");
var assemblyFileName = Path.Combine(OutputPath, Path.GetFileName(oridgAssemblyFileName));
File.Copy(oridgAssemblyFileName, assemblyFileName);
File.Copy(origPdbFileName, Path.Combine(OutputPath, Path.GetFileName(origPdbFileName)));
var options = new InstrumentationOptions(
new[] { assemblyFileName },
Array.Empty <string>(), OutputPath, PortNumber);
Instrumenter instrumenter = new Instrumenter(options, _logger);
instrumenter.BackupFolder = Path.Combine(OutputPath, "backup");
Directory.CreateDirectory(instrumenter.BackupFolder);
RecordingController = instrumenter.Instrument();
InstrumentedAssemblyPath = assemblyFileName;
}
public MongoRepository(IInventoryDatabaseSettings settings)
{
var clientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString);
var options = new InstrumentationOptions {
CaptureCommandText = true
};
clientSettings.ClusterConfigurator = cb => cb.Subscribe(new DiagnosticsActivityEventSubscriber(options));
var database = new MongoClient(clientSettings).GetDatabase(settings.DatabaseName);
_collection = database.GetCollection <TDocument>(GetCollectionName(typeof(TDocument)));
}
public void HttpClient_SubmitsTraces(InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
ConfigureInstrumentation(instrumentation, enableSocketsHandler);
var expectedAsyncCount = CalculateExpectedAsyncSpans(instrumentation);
var expectedSyncCount = CalculateExpectedSyncSpans(instrumentation);
var expectedSpanCount = expectedAsyncCount + expectedSyncCount;
const string expectedOperationName = "http.request";
const string expectedServiceName = "Samples.HttpMessageHandler-http-client";
int httpPort = TcpPortProvider.GetOpenPort();
Output.WriteLine($"Assigning port {httpPort} for the httpPort.");
using var telemetry = this.ConfigureTelemetry();
using (var agent = EnvironmentHelper.GetMockAgent())
using (ProcessResult processResult = RunSampleAndWaitForExit(agent, arguments: $"Port={httpPort}"))
{
var spans = agent.WaitForSpans(expectedSpanCount, operationName: expectedOperationName);
Assert.Equal(expectedSpanCount, spans.Count);
foreach (var span in spans)
{
Assert.Equal(expectedOperationName, span.Name);
Assert.Equal(expectedServiceName, span.Service);
Assert.Equal(SpanTypes.Http, span.Type);
Assert.Equal("HttpMessageHandler", span.Tags[Tags.InstrumentationName]);
Assert.False(span.Tags?.ContainsKey(Tags.Version), "External service span should not have service version tag.");
if (span.Tags[Tags.HttpStatusCode] == "502")
{
Assert.Equal(1, span.Error);
}
}
var firstSpan = spans.First();
var traceId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TraceId);
var parentSpanId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.ParentId);
Assert.Equal(firstSpan.TraceId.ToString(CultureInfo.InvariantCulture), traceId);
Assert.Equal(firstSpan.SpanId.ToString(CultureInfo.InvariantCulture), parentSpanId);
using var scope = new AssertionScope();
telemetry.AssertIntegrationEnabled(IntegrationId.HttpMessageHandler);
// ignore for now auto enabled for simplicity
telemetry.AssertIntegration(IntegrationId.HttpSocketsHandler, enabled: IsUsingSocketHandler(instrumentation), autoEnabled: null);
telemetry.AssertIntegration(IntegrationId.WinHttpHandler, enabled: IsUsingWinHttpHandler(instrumentation), autoEnabled: null);
telemetry.AssertIntegration(IntegrationId.CurlHandler, enabled: IsUsingCurlHandler(instrumentation), autoEnabled: null);
}
}
public void HttpClient_SubmitsTraces(bool enableCallTarget, InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
ConfigureInstrumentation(enableCallTarget, instrumentation, enableSocketsHandler);
var expectedAsyncCount = CalculateExpectedAsyncSpans(instrumentation, enableCallTarget);
var expectedSyncCount = CalculateExpectedSyncSpans(instrumentation);
var expectedSpanCount = expectedAsyncCount + expectedSyncCount;
const string expectedOperationName = "http.request";
const string expectedServiceName = "Samples.HttpMessageHandler-http-client";
int agentPort = TcpPortProvider.GetOpenPort();
int httpPort = TcpPortProvider.GetOpenPort();
Output.WriteLine($"Assigning port {agentPort} for the agentPort.");
Output.WriteLine($"Assigning port {httpPort} for the httpPort.");
using (var agent = new MockTracerAgent(agentPort))
using (ProcessResult processResult = RunSampleAndWaitForExit(agent.Port, arguments: $"Port={httpPort}"))
{
Assert.True(processResult.ExitCode >= 0, $"Process exited with code {processResult.ExitCode}");
var spans = agent.WaitForSpans(expectedSpanCount, operationName: expectedOperationName);
Assert.Equal(expectedSpanCount, spans.Count);
foreach (var span in spans)
{
Assert.Equal(expectedOperationName, span.Name);
Assert.Equal(expectedServiceName, span.Service);
Assert.Equal(SpanTypes.Http, span.Type);
Assert.Equal("HttpMessageHandler", span.Tags[Tags.InstrumentationName]);
Assert.False(span.Tags?.ContainsKey(Tags.Version), "External service span should not have service version tag.");
if (span.Tags[Tags.HttpStatusCode] == "502")
{
Assert.Equal(1, span.Error);
}
}
var firstSpan = spans.First();
var traceId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.TraceId);
var parentSpanId = StringUtil.GetHeader(processResult.StandardOutput, HttpHeaderNames.ParentId);
Assert.Equal(firstSpan.TraceId.ToString(CultureInfo.InvariantCulture), traceId);
Assert.Equal(firstSpan.SpanId.ToString(CultureInfo.InvariantCulture), parentSpanId);
}
}
private void ConfigureInstrumentation(InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
// Should HttpClient try to use HttpSocketsHandler
SetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_USESOCKETSHTTPHANDLER", enableSocketsHandler ? "1" : "0");
// Enable specific integrations, or use defaults
if (instrumentation.InstrumentSocketHandler.HasValue)
{
SetEnvironmentVariable("DD_HttpSocketsHandler_ENABLED", instrumentation.InstrumentSocketHandler.Value ? "true" : "false");
}
if (instrumentation.InstrumentWinHttpOrCurlHandler.HasValue)
{
SetEnvironmentVariable("DD_WinHttpHandler_ENABLED", instrumentation.InstrumentWinHttpOrCurlHandler.Value ? "true" : "false");
SetEnvironmentVariable("DD_CurlHandler_ENABLED", instrumentation.InstrumentWinHttpOrCurlHandler.Value ? "true" : "false");
}
}
public static MongoClientSettings AddInstrumentation(
this MongoClientSettings mongoClientSettings,
Action <InstrumentationOptions>?configureInstrumentation = default,
Action <ClusterBuilder>?configureCluster = default)
{
var instrumentationOptions = new InstrumentationOptions {
CaptureCommandText = true
};
configureInstrumentation?.Invoke(instrumentationOptions);
mongoClientSettings.ClusterConfigurator = builder =>
{
builder.Subscribe(new DiagnosticsActivityEventSubscriber(instrumentationOptions));
configureCluster?.Invoke(builder);
};
return(mongoClientSettings);
}
public void TracingDisabled_DoesNotSubmitsTraces(bool enableCallTarget, InstrumentationOptions instrumentation, bool enableSocketsHandler)
{
ConfigureInstrumentation(enableCallTarget, instrumentation, enableSocketsHandler);
const string expectedOperationName = "http.request";
int agentPort = TcpPortProvider.GetOpenPort();
int httpPort = TcpPortProvider.GetOpenPort();
using (var agent = new MockTracerAgent(agentPort))
using (ProcessResult processResult = RunSampleAndWaitForExit(agent.Port, arguments: $"TracingDisabled Port={httpPort}"))
{
Assert.True(processResult.ExitCode >= 0, $"Process exited with code {processResult.ExitCode}");
var spans = agent.WaitForSpans(1, 2000, operationName: expectedOperationName);
Assert.Equal(0, spans.Count);
PropagationTestHelpers.AssertPropagationDisabled(processResult);
}
}
private static int CalculateExpectedSyncSpans(InstrumentationOptions instrumentation)
{
// Sync requests are only enabled in .NET 5
if (!EnvironmentHelper.IsNet5())
{
return(0);
}
var spansPerHttpClient = 21;
var expectedSpanCount = spansPerHttpClient * 2; // default HttpClient and CustomHttpClientHandler
// SocketsHttpHandler instrumentation is on by default
if (instrumentation.InstrumentSocketHandler ?? true)
{
expectedSpanCount += spansPerHttpClient;
}
return(expectedSpanCount);
}
private static bool IsUsingSocketHandler(InstrumentationOptions instrumentation)
{
// SocketsHttpHandler instrumentation is on by default
return(IsSocketsHandlerSupported() && (instrumentation.InstrumentSocketHandler ?? true));
}
private static bool IsUsingCurlHandler(InstrumentationOptions instrumentation)
{
return(IsCurlHandlerSupported() && (instrumentation.InstrumentWinHttpOrCurlHandler == true));
}
private static bool IsUsingWinHttpHandler(InstrumentationOptions instrumentation)
{
// WinHttpHandler instrumentation is off by default, and only available on Windows
return(IsWinHttpHandlerSupported() && (instrumentation.InstrumentWinHttpOrCurlHandler == true));
}
