public void SqlClientInstrumentationOptions_EnableConnectionLevelAttributes(
bool enableConnectionLevelAttributes,
string dataSource,
string expectedServerHostName,
string expectedServerIpAddress,
string expectedInstanceName,
string expectedPort)
{
var source = new ActivitySource("sql-client-instrumentation");
var activity = source.StartActivity("Test Sql Activity");
var options = new SqlClientInstrumentationOptions
{
EnableConnectionLevelAttributes = enableConnectionLevelAttributes,
};
options.AddConnectionLevelDetailsToActivity(dataSource, activity);
if (!enableConnectionLevelAttributes)
{
Assert.Equal(expectedServerHostName, activity.GetTagValue(SemanticConventions.AttributePeerService));
}
else
{
Assert.Equal(expectedServerHostName, activity.GetTagValue(SemanticConventions.AttributeNetPeerName));
}
Assert.Equal(expectedServerIpAddress, activity.GetTagValue(SemanticConventions.AttributeNetPeerIp));
Assert.Equal(expectedInstanceName, activity.GetTagValue(SemanticConventions.AttributeDbMsSqlInstanceName));
Assert.Equal(expectedPort, activity.GetTagValue(SemanticConventions.AttributeNetPeerPort));
}
/// <summary>
/// Enables the outgoing requests automatic data collection.
/// </summary>
/// <param name="builder">Trace builder to use.</param>
/// <param name="configureHttpInstrumentationOptions">Http configuration options.</param>
/// <param name="configureSqlInstrumentationOptions">Sql configuration options.</param>
/// <returns>The instance of <see cref="TracerBuilder"/> to chain the calls.</returns>
public static TracerBuilder AddDependencyInstrumentation(
this TracerBuilder builder,
Action <HttpClientInstrumentationOptions> configureHttpInstrumentationOptions = null,
Action <SqlClientInstrumentationOptions> configureSqlInstrumentationOptions = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var httpOptions = new HttpClientInstrumentationOptions();
configureHttpInstrumentationOptions?.Invoke(httpOptions);
var sqlOptions = new SqlClientInstrumentationOptions();
configureSqlInstrumentationOptions?.Invoke(sqlOptions);
return(builder
.AddInstrumentation((t) => new AzureClientsInstrumentation(t))
.AddInstrumentation((t) => new AzurePipelineInstrumentation(t))
.AddInstrumentation((t) => new HttpClientInstrumentation(t, httpOptions))
.AddInstrumentation((t) => new HttpWebRequestInstrumentation(t, httpOptions))
.AddInstrumentation((t) => new SqlClientInstrumentation(t, sqlOptions)));
}
public void ParseDataSourceTests(
string dataSource,
string expectedServerHostName,
string expectedServerIpAddress,
string expectedInstanceName,
string expectedPort)
{
var sqlConnectionDetails = SqlClientInstrumentationOptions.ParseDataSource(dataSource);
Assert.NotNull(sqlConnectionDetails);
Assert.Equal(expectedServerHostName, sqlConnectionDetails.ServerHostName);
Assert.Equal(expectedServerIpAddress, sqlConnectionDetails.ServerIpAddress);
Assert.Equal(expectedInstanceName, sqlConnectionDetails.InstanceName);
Assert.Equal(expectedPort, sqlConnectionDetails.Port);
}
/// <summary>
/// Enables SqlClient instrumentation.
/// </summary>
/// <param name="builder"><see cref="TracerProviderBuilder"/> being configured.</param>
/// <param name="configureSqlClientInstrumentationOptions">SqlClient configuration options.</param>
/// <returns>The instance of <see cref="TracerProviderBuilder"/> to chain the calls.</returns>
public static TracerProviderBuilder AddSqlClientInstrumentation(
this TracerProviderBuilder builder,
Action <SqlClientInstrumentationOptions> configureSqlClientInstrumentationOptions = null)
{
Guard.ThrowIfNull(builder);
var sqlOptions = new SqlClientInstrumentationOptions();
configureSqlClientInstrumentationOptions?.Invoke(sqlOptions);
builder.AddInstrumentation(() => new SqlClientInstrumentation(sqlOptions));
builder.AddSource(SqlActivitySourceHelper.ActivitySourceName);
return(builder);
}
/// <summary>
/// Enables the outgoing requests automatic data collection for SqlClient.
/// </summary>
/// <param name="builder"><see cref="OpenTelemetryBuilder"/> being configured.</param>
/// <param name="configureSqlClientInstrumentationOptions">SqlClient configuration options.</param>
/// <returns>The instance of <see cref="OpenTelemetryBuilder"/> to chain the calls.</returns>
public static OpenTelemetryBuilder AddSqlClientDependencyInstrumentation(
this OpenTelemetryBuilder builder,
Action <SqlClientInstrumentationOptions> configureSqlClientInstrumentationOptions)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var sqlOptions = new SqlClientInstrumentationOptions();
configureSqlClientInstrumentationOptions?.Invoke(sqlOptions);
builder.AddInstrumentation((activitySource) => new SqlClientInstrumentation(activitySource, sqlOptions));
return(builder);
}
/// <summary>
/// Enables SqlClient instrumentation.
/// </summary>
/// <param name="builder"><see cref="TracerProviderBuilder"/> being configured.</param>
/// <param name="configureSqlClientInstrumentationOptions">SqlClient configuration options.</param>
/// <returns>The instance of <see cref="TracerProviderBuilder"/> to chain the calls.</returns>
public static TracerProviderBuilder AddSqlClientInstrumentation(
this TracerProviderBuilder builder,
Action <SqlClientInstrumentationOptions> configureSqlClientInstrumentationOptions = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var sqlOptions = new SqlClientInstrumentationOptions();
configureSqlClientInstrumentationOptions?.Invoke(sqlOptions);
builder.AddInstrumentation(() => new SqlClientInstrumentation(sqlOptions));
builder.AddSource(SqlClientDiagnosticListener.ActivitySourceName);
return(builder);
}
/// <summary>
/// Enables the outgoing requests automatic data collection for SqlClient.
/// </summary>
/// <param name="builder"><see cref="OpenTelemetryBuilder"/> being configured.</param>
/// <param name="configureSqlClientInstrumentationOptions">SqlClient configuration options.</param>
/// <returns>The instance of <see cref="OpenTelemetryBuilder"/> to chain the calls.</returns>
public static OpenTelemetryBuilder AddSqlClientDependencyInstrumentation(
this OpenTelemetryBuilder builder,
Action <SqlClientInstrumentationOptions> configureSqlClientInstrumentationOptions)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
// HttpClient is not instrumented with ActivitySource, hence
// it'll have a default ActivitySource with name string.Empty.
builder.AddActivitySource(string.Empty);
var sqlOptions = new SqlClientInstrumentationOptions();
configureSqlClientInstrumentationOptions?.Invoke(sqlOptions);
builder.AddInstrumentation(() => new SqlClientInstrumentation(sqlOptions));
return(builder);
}
public SqlEventSourceListener(SqlClientInstrumentationOptions options = null)
{
this.options = options ?? new SqlClientInstrumentationOptions();
}
public SqlClientDiagnosticListener(string sourceName, SqlClientInstrumentationOptions options)
: base(sourceName)
{
this.options = options ?? new SqlClientInstrumentationOptions();
}
private static void VerifyActivityData(
CommandType commandType,
string commandText,
bool captureText,
bool isFailure,
string dataSource,
Activity activity,
bool enableConnectionLevelAttributes = false)
{
Assert.Equal("master", activity.DisplayName);
Assert.Equal(ActivityKind.Client, activity.Kind);
Assert.Equal(SqlClientDiagnosticListener.MicrosoftSqlServerDatabaseSystemName, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeDbSystem).Value);
if (!enableConnectionLevelAttributes)
{
Assert.Equal(dataSource, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributePeerService).Value);
}
else
{
var connectionDetails = SqlClientInstrumentationOptions.ParseDataSource(dataSource);
if (!string.IsNullOrEmpty(connectionDetails.ServerHostName))
{
Assert.Equal(connectionDetails.ServerHostName, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeNetPeerName).Value);
}
else
{
Assert.Equal(connectionDetails.ServerIpAddress, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeNetPeerIp).Value);
}
if (!string.IsNullOrEmpty(connectionDetails.InstanceName))
{
Assert.Equal(connectionDetails.InstanceName, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeDbMsSqlInstanceName).Value);
}
if (!string.IsNullOrEmpty(connectionDetails.Port))
{
Assert.Equal(connectionDetails.Port, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeNetPeerPort).Value);
}
}
Assert.Equal("master", activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeDbName).Value);
Assert.Equal(commandType.ToString(), activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.DatabaseStatementTypeKey).Value);
if (commandType == CommandType.StoredProcedure)
{
if (captureText)
{
Assert.Equal(commandText, activity.Tags.FirstOrDefault(t => t.Key == SemanticConventions.AttributeDbStatement).Value);
}
else
{
Assert.DoesNotContain(activity.Tags, t => t.Key == SemanticConventions.AttributeDbStatement);
}
}
if (!isFailure)
{
Assert.Equal("Ok", activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).Value);
}
else
{
Assert.Equal("Unknown", activity.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).Value);
Assert.Contains(activity.Tags, t => t.Key == SpanAttributeConstants.StatusDescriptionKey);
}
}
private static void VerifyActivityData(
string commandText,
bool captureText,
bool isFailure,
string dataSource,
Activity activity,
bool enableConnectionLevelAttributes = false)
{
Assert.Equal("master", activity.DisplayName);
Assert.Equal(ActivityKind.Client, activity.Kind);
Assert.Equal(SqlActivitySourceHelper.MicrosoftSqlServerDatabaseSystemName, activity.GetTagValue(SemanticConventions.AttributeDbSystem));
if (!enableConnectionLevelAttributes)
{
Assert.Equal(dataSource, activity.GetTagValue(SemanticConventions.AttributePeerService));
}
else
{
var connectionDetails = SqlClientInstrumentationOptions.ParseDataSource(dataSource);
if (!string.IsNullOrEmpty(connectionDetails.ServerHostName))
{
Assert.Equal(connectionDetails.ServerHostName, activity.GetTagValue(SemanticConventions.AttributeNetPeerName));
}
else
{
Assert.Equal(connectionDetails.ServerIpAddress, activity.GetTagValue(SemanticConventions.AttributeNetPeerIp));
}
if (!string.IsNullOrEmpty(connectionDetails.InstanceName))
{
Assert.Equal(connectionDetails.InstanceName, activity.GetTagValue(SemanticConventions.AttributeDbMsSqlInstanceName));
}
if (!string.IsNullOrEmpty(connectionDetails.Port))
{
Assert.Equal(connectionDetails.Port, activity.GetTagValue(SemanticConventions.AttributeNetPeerPort));
}
}
Assert.Equal("master", activity.GetTagValue(SemanticConventions.AttributeDbName));
// "db.statement_type" is never set by the SqlEventSource instrumentation
Assert.Null(activity.GetTagValue(SpanAttributeConstants.DatabaseStatementTypeKey));
if (captureText)
{
Assert.Equal(commandText, activity.GetTagValue(SemanticConventions.AttributeDbStatement));
}
else
{
Assert.Null(activity.GetTagValue(SemanticConventions.AttributeDbStatement));
}
if (!isFailure)
{
Assert.Equal(Status.Unset, activity.GetStatus());
}
else
{
var status = activity.GetStatus();
Assert.Equal(Status.Error.StatusCode, status.StatusCode);
Assert.NotNull(status.Description);
}
}
public SqlClientDiagnosticListener(string sourceName, SqlClientInstrumentationOptions options, ActivitySourceAdapter activitySource)
: base(sourceName, null)
{
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.activitySource = activitySource;
}
public SqlClientDiagnosticListener(string sourceName, Tracer tracer, SqlClientInstrumentationOptions options)
: base(sourceName, tracer)
{
this.options = options ?? throw new ArgumentNullException(nameof(options));
}
