();
services.AddMvc();
}
public void Configure(IApplicationBuilder app)
{
app.UseDeveloperExceptionPage();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapDefaultControllerRoute();
});
}
}
}
================================================
FILE: samples/netcoreapp3.1/FrontendWeb/Views/Home/Index.cshtml
================================================
FrontendWeb
FrontendWeb
This is the beautiful web frontend.
Refresh this page a few times and check the Jaeger UI - you should already see traces!
Place an order
================================================
FILE: samples/netcoreapp3.1/FrontendWeb/Views/Home/PlaceOrder.cshtml
================================================
@model Shared.PlaceOrderCommand
FrontendWeb
FrontendWeb
Place an order
================================================
FILE: samples/netcoreapp3.1/FrontendWeb/Views/_ViewImports.cshtml
================================================
@using Samples.FrontendWeb
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
================================================
FILE: samples/netcoreapp3.1/FrontendWeb/appsettings.json
================================================
{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information",
"OpenTracing": "Debug"
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/Controllers/OrdersController.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using OpenTracing;
using OrdersApi.DataStore;
using Shared;
namespace Samples.OrdersApi.Controllers
{
[Route("orders")]
public class OrdersController : Controller
{
private readonly OrdersDbContext _dbContext;
private readonly HttpClient _httpClient;
private readonly ITracer _tracer;
public OrdersController(OrdersDbContext dbContext, HttpClient httpClient, ITracer tracer)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
_httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
}
[HttpGet]
public async Task Index()
{
var orders = await _dbContext.Orders.ToListAsync();
return Ok(orders.Select(x => new { x.OrderId }).ToList());
}
[HttpPost]
public async Task Index([FromBody] PlaceOrderCommand cmd)
{
var customer = await GetCustomer(cmd.CustomerId.Value);
var order = new Order
{
CustomerId = cmd.CustomerId.Value,
ItemNumber = cmd.ItemNumber,
Quantity = cmd.Quantity
};
_dbContext.Orders.Add(order);
await _dbContext.SaveChangesAsync();
_tracer.ActiveSpan?.Log(new Dictionary {
{ "event", "OrderPlaced" },
{ "orderId", order.OrderId },
{ "customer", order.CustomerId },
{ "customer_name", customer.Name },
{ "item_number", order.ItemNumber },
{ "quantity", order.Quantity }
});
return Ok();
}
private async Task GetCustomer(int customerId)
{
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(Constants.CustomersUrl + "customers/" + customerId)
};
var response = await _httpClient.SendAsync(request);
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
return JsonConvert.DeserializeObject(body);
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/DataStore/Order.cs
================================================
using System;
using System.ComponentModel.DataAnnotations;
namespace OrdersApi.DataStore
{
public class Order
{
[Key]
public int OrderId { get; set; }
public int CustomerId { get; set; }
[Required, StringLength(10)]
public string ItemNumber { get; set; }
[Required, Range(1, 100)]
public int Quantity { get; set; }
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/DataStore/OrdersDbContext.cs
================================================
using Microsoft.EntityFrameworkCore;
namespace OrdersApi.DataStore
{
public class OrdersDbContext : DbContext
{
public OrdersDbContext(DbContextOptions options)
: base(options)
{
}
public DbSet Orders { get; set; }
public void Seed()
{
if (Database.EnsureCreated())
{
Database.Migrate();
SaveChanges();
}
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/OrdersApi.csproj
================================================
netcoreapp3.1
================================================
FILE: samples/netcoreapp3.1/OrdersApi/Program.cs
================================================
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Shared;
namespace Samples.OrdersApi
{
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder
.UseStartup()
.UseUrls(Constants.OrdersUrl);
})
.ConfigureServices(services =>
{
// Registers and starts Jaeger (see Shared.JaegerServiceCollectionExtensions)
services.AddJaeger();
// Enables OpenTracing instrumentation for ASP.NET Core, CoreFx, EF Core
services.AddOpenTracing(builder =>
{
builder.ConfigureAspNetCore(options =>
{
// We don't need any tracing data for our health endpoint.
options.Hosting.IgnorePatterns.Add(ctx => ctx.Request.Path == "/health");
});
});
});
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/Properties/launchSettings.json
================================================
{
"profiles": {
"OrdersApi": {
"commandName": "Project",
"launchBrowser": false,
"launchUrl": "http://localhost:5002",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/Startup.cs
================================================
using System;
using System.Net.Http;
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using OrdersApi.DataStore;
namespace Samples.OrdersApi
{
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
// Adds a SqlServer DB to show EFCore traces.
services
.AddDbContext(options =>
{
options.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=Orders-netcoreapp31;Trusted_Connection=True;MultipleActiveResultSets=true");
});
services.AddSingleton();
services.AddMvc();
services.AddHealthChecks()
.AddDbContextCheck();
}
public void Configure(IApplicationBuilder app)
{
// Load some dummy data into the db.
BootstrapDataStore(app.ApplicationServices);
app.UseDeveloperExceptionPage();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapDefaultControllerRoute();
endpoints.MapHealthChecks("/health");
});
}
private void BootstrapDataStore(IServiceProvider serviceProvider)
{
using (var scope = serviceProvider.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService();
dbContext.Seed();
}
}
}
}
================================================
FILE: samples/netcoreapp3.1/OrdersApi/appsettings.json
================================================
{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Information"
}
}
}
================================================
FILE: samples/netcoreapp3.1/Shared/Constants.cs
================================================
namespace Shared
{
public class Constants
{
public const string FrontendUrl = "http://localhost:5000/";
public const string CustomersUrl = "http://localhost:5001/";
public const string OrdersUrl = "http://localhost:5002/";
}
}
================================================
FILE: samples/netcoreapp3.1/Shared/Customer.cs
================================================
namespace Shared
{
public class Customer
{
public int CustomerId { get; set; }
public string Name { get; set; }
public Customer()
{
}
public Customer(int customerId, string name)
{
CustomerId = customerId;
Name = name;
}
}
}
================================================
FILE: samples/netcoreapp3.1/Shared/JaegerServiceCollectionExtensions.cs
================================================
using System;
using System.Reflection;
using Jaeger;
using Jaeger.Reporters;
using Jaeger.Samplers;
using Jaeger.Senders.Thrift;
using Microsoft.Extensions.Logging;
using OpenTracing;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Util;
namespace Microsoft.Extensions.DependencyInjection
{
public static class JaegerServiceCollectionExtensions
{
private static readonly Uri _jaegerUri = new Uri("http://localhost:14268/api/traces");
public static IServiceCollection AddJaeger(this IServiceCollection services)
{
if (services == null)
throw new ArgumentNullException(nameof(services));
services.AddSingleton(serviceProvider =>
{
string serviceName = Assembly.GetEntryAssembly().GetName().Name;
ILoggerFactory loggerFactory = serviceProvider.GetRequiredService();
ISampler sampler = new ConstSampler(sample: true);
IReporter reporter = new RemoteReporter.Builder()
.WithSender(new HttpSender.Builder(_jaegerUri.ToString()).Build())
.Build();
ITracer tracer = new Tracer.Builder(serviceName)
.WithLoggerFactory(loggerFactory)
.WithSampler(sampler)
.WithReporter(reporter)
.Build();
GlobalTracer.Register(tracer);
return tracer;
});
// Prevent endless loops when OpenTracing is tracking HTTP requests to Jaeger.
services.Configure(options =>
{
options.IgnorePatterns.Add(request => _jaegerUri.IsBaseOf(request.RequestUri));
});
return services;
}
}
}
================================================
FILE: samples/netcoreapp3.1/Shared/PlaceOrderCommand.cs
================================================
using System.ComponentModel.DataAnnotations;
namespace Shared
{
public class PlaceOrderCommand
{
[Required]
public int? CustomerId { get; set; }
[Required, StringLength(10)]
public string ItemNumber { get; set; }
[Required, Range(1, 100)]
public int Quantity { get; set; }
}
}
================================================
FILE: samples/netcoreapp3.1/Shared/Shared.csproj
================================================
netcoreapp3.1
================================================
FILE: samples/netcoreapp3.1/TrafficGenerator/Program.cs
================================================
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
namespace TrafficGenerator
{
class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices(services =>
{
// Registers and starts Jaeger (see Shared.JaegerServiceCollectionExtensions)
services.AddJaeger();
services.AddOpenTracing();
services.AddHostedService();
});
}
}
================================================
FILE: samples/netcoreapp3.1/TrafficGenerator/TrafficGenerator.csproj
================================================
netcoreapp3.1
================================================
FILE: samples/netcoreapp3.1/TrafficGenerator/Worker.cs
================================================
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Shared;
namespace TrafficGenerator
{
public class Worker : BackgroundService
{
private readonly ILogger _logger;
public Worker(ILogger logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
try
{
HttpClient customersHttpClient = new HttpClient();
customersHttpClient.BaseAddress = new Uri(Constants.CustomersUrl);
HttpClient ordersHttpClient = new HttpClient();
ordersHttpClient.BaseAddress = new Uri(Constants.OrdersUrl);
while (!stoppingToken.IsCancellationRequested)
{
HttpResponseMessage ordershealthResponse = await ordersHttpClient.GetAsync("health");
_logger.LogInformation($"Health of 'orders'-endpoint: '{ordershealthResponse.StatusCode}'");
HttpResponseMessage customersHealthResponse = await customersHttpClient.GetAsync("health");
_logger.LogInformation($"Health of 'customers'-endpoint: '{customersHealthResponse.StatusCode}'");
_logger.LogInformation("Requesting customers");
HttpResponseMessage response = await customersHttpClient.GetAsync("customers");
_logger.LogInformation($"Response was '{response.StatusCode}'");
await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
}
}
catch (TaskCanceledException)
{
/* Application should be stopped -> no-op */
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception");
}
}
}
}
================================================
FILE: samples/netcoreapp3.1/TrafficGenerator/appsettings.json
================================================
{
"Logging": {
"LogLevel": {
"Default": "Debug",
"System": "Information",
"Microsoft": "Warning",
"Microsoft.AspNetCore.Hosting": "Information"
}
}
}
================================================
FILE: src/Directory.Build.props
================================================
true
Christian Weiss
package-icon.png
https://avatars0.githubusercontent.com/u/15482765
https://github.com/opentracing-contrib/csharp-netcore
Apache-2.0
https://github.com/opentracing-contrib/csharp-netcore/releases/tag/v$(Version)
$(NoWarn);CS1591
true
true
true
snupkg
================================================
FILE: src/OpenTracing.Contrib.NetCore/AspNetCore/AspNetCoreDiagnosticOptions.cs
================================================
using OpenTracing.Contrib.NetCore.AspNetCore;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public class AspNetCoreDiagnosticOptions : DiagnosticOptions
{
public HostingOptions Hosting { get; } = new HostingOptions();
public AspNetCoreDiagnosticOptions()
{
// We create separate spans for MVC actions & results so we don't need these additional events by default.
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnActionExecution");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnActionExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnActionExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeActionMethod");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeControllerActionMethod");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterControllerActionMethod");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterActionMethod");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnActionExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnActionExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnActionExecution");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnActionExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnActionExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnActionExecution");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnResultExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnResultExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnResultExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnResourceExecuted");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.AfterOnResourceExecuting");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.Razor.BeginInstrumentationContext");
IgnoredEvents.Add("Microsoft.AspNetCore.Mvc.Razor.EndInstrumentationContext");
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/AspNetCore/AspNetCoreDiagnostics.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Propagation;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.AspNetCore
{
///
/// Instruments ASP.NET Core.
///
/// Unfortunately, ASP.NET Core only uses one instance
/// for everything so we also only create one observer to ensure best performance.
/// Hosting events: https://github.com/aspnet/Hosting/blob/dev/src/Microsoft.AspNetCore.Hosting/Internal/HostingApplicationDiagnostics.cs
///
internal sealed class AspNetCoreDiagnostics : DiagnosticEventObserver
{
public const string DiagnosticListenerName = "Microsoft.AspNetCore";
private const string HostingScopeItemsKey = "ot-HttpRequestIn";
private const string ActionScopeItemsKey = "ot-MvcAction";
private const string ActionResultScopeItemsKey = "ot-MvcActionResult";
private const string ActionComponent = "AspNetCore.MvcAction";
private const string ActionTagActionName = "action";
private const string ActionTagControllerName = "controller";
private const string ResultComponent = "AspNetCore.MvcResult";
private const string ResultTagType = "result.type";
private static readonly PropertyFetcher _httpRequestIn_start_HttpContextFetcher = new PropertyFetcher("HttpContext");
private static readonly PropertyFetcher _httpRequestIn_stop_HttpContextFetcher = new PropertyFetcher("HttpContext");
private static readonly PropertyFetcher _unhandledException_HttpContextFetcher = new PropertyFetcher("httpContext");
private static readonly PropertyFetcher _unhandledException_ExceptionFetcher = new PropertyFetcher("exception");
private static readonly PropertyFetcher _beforeAction_httpContextFetcher = new PropertyFetcher("httpContext");
private static readonly PropertyFetcher _beforeAction_ActionDescriptorFetcher = new PropertyFetcher("actionDescriptor");
private static readonly PropertyFetcher _afterAction_httpContextFetcher = new PropertyFetcher("httpContext");
private static readonly PropertyFetcher _beforeActionResult_actionContextFetcher = new PropertyFetcher("actionContext");
private static readonly PropertyFetcher _beforeActionResult_ResultFetcher = new PropertyFetcher("result");
private static readonly PropertyFetcher _afterActionResult_actionContextFetcher = new PropertyFetcher("actionContext");
internal static readonly string NoHostSpecified = string.Empty;
private readonly AspNetCoreDiagnosticOptions _options;
public AspNetCoreDiagnostics(ILoggerFactory loggerFactory, ITracer tracer, IOptions options)
: base(loggerFactory, tracer, options?.Value)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
}
protected override string GetListenerName() => DiagnosticListenerName;
protected override bool IsSupportedEvent(string eventName)
{
return eventName switch
{
// We don't want to get the old deprecated Hosting events.
"Microsoft.AspNetCore.Hosting.BeginRequest" => false,
"Microsoft.AspNetCore.Hosting.EndRequest" => false,
_ => true,
};
}
protected override IEnumerable HandledEventNames()
{
yield return "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start";
yield return "Microsoft.AspNetCore.Hosting.UnhandledException";
yield return "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop";
yield return "Microsoft.AspNetCore.Mvc.BeforeAction";
yield return "Microsoft.AspNetCore.Mvc.AfterAction";
yield return "Microsoft.AspNetCore.Mvc.BeforeActionResult";
yield return "Microsoft.AspNetCore.Mvc.AfterActionResult";
}
protected override void HandleEvent(string eventName, object untypedArg)
{
switch (eventName)
{
case "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start":
{
var httpContext = (HttpContext)_httpRequestIn_start_HttpContextFetcher.Fetch(untypedArg);
if (Tracer.ActiveSpan == null && !_options.StartRootSpans)
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring request due to missing parent span");
}
return;
}
if (ShouldIgnore(httpContext))
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring request");
}
}
else
{
var request = httpContext.Request;
ISpanContext extractedSpanContext = null;
if (_options.Hosting.ExtractEnabled?.Invoke(httpContext) ?? true)
{
extractedSpanContext = Tracer.Extract(BuiltinFormats.HttpHeaders, new RequestHeadersExtractAdapter(request.Headers));
}
string operationName = _options.Hosting.OperationNameResolver(httpContext);
IScope scope = Tracer.BuildSpan(operationName)
.AsChildOf(extractedSpanContext)
.WithTag(Tags.Component, _options.Hosting.ComponentName)
.WithTag(Tags.SpanKind, Tags.SpanKindServer)
.WithTag(Tags.HttpMethod, request.Method)
.WithTag(Tags.HttpUrl, GetDisplayUrl(request))
.StartActive();
_options.Hosting.OnRequest?.Invoke(scope.Span, httpContext);
httpContext.Items[HostingScopeItemsKey] = scope;
}
}
break;
case "Microsoft.AspNetCore.Hosting.UnhandledException":
{
var httpContext = (HttpContext)_unhandledException_HttpContextFetcher.Fetch(untypedArg);
var exception = (Exception)_unhandledException_ExceptionFetcher.Fetch(untypedArg);
var scope = httpContext.Items[HostingScopeItemsKey] as IScope;
if (scope != null)
{
var span = scope.Span;
span.SetException(exception);
_options.Hosting.OnError?.Invoke(span, exception, httpContext);
}
}
break;
case "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop":
{
var httpContext = (HttpContext)_httpRequestIn_stop_HttpContextFetcher.Fetch(untypedArg);
var scope = httpContext.Items[HostingScopeItemsKey] as IScope;
if (scope != null)
{
httpContext.Items.Remove(HostingScopeItemsKey);
scope.Span.SetTag(Tags.HttpStatus, httpContext.Response.StatusCode);
scope.Dispose();
}
httpContext.Items.Remove(ActionResultScopeItemsKey);
httpContext.Items.Remove(ActionScopeItemsKey);
}
break;
case "Microsoft.AspNetCore.Mvc.BeforeAction":
{
var httpContext = (HttpContext)_beforeAction_httpContextFetcher.Fetch(untypedArg);
// We only create this span if the entire request should be traced.
var scope = httpContext.Items[HostingScopeItemsKey] as IScope;
if (scope != null)
{
// NOTE: This event is the start of the action pipeline. The action has been selected, the route
// has been selected but no filters have run and model binding hasn't occured.
var actionDescriptor = (ActionDescriptor)_beforeAction_ActionDescriptorFetcher.Fetch(untypedArg);
var controllerActionDescriptor = actionDescriptor as ControllerActionDescriptor;
string operationName = controllerActionDescriptor != null
? $"Action {controllerActionDescriptor.ControllerTypeInfo.FullName}/{controllerActionDescriptor.ActionName}"
: $"Action {actionDescriptor.DisplayName}";
var actionScope = Tracer.BuildSpan(operationName)
.AsChildOf(scope.Span)
.WithTag(Tags.Component, ActionComponent)
.WithTag(ActionTagControllerName, controllerActionDescriptor?.ControllerTypeInfo.FullName)
.WithTag(ActionTagActionName, controllerActionDescriptor?.ActionName)
.StartActive();
httpContext.Items[ActionScopeItemsKey] = actionScope;
}
}
break;
case "Microsoft.AspNetCore.Mvc.AfterAction":
{
var httpContext = (HttpContext)_afterAction_httpContextFetcher.Fetch(untypedArg);
var scope = httpContext.Items[ActionScopeItemsKey] as IScope;
if (scope != null)
{
httpContext.Items.Remove(ActionScopeItemsKey);
scope.Dispose();
}
}
break;
case "Microsoft.AspNetCore.Mvc.BeforeActionResult":
{
var httpContext = ((ActionContext)_beforeActionResult_actionContextFetcher.Fetch(untypedArg)).HttpContext;
// We only create this span if the entire request should be traced.
var scope = httpContext.Items[HostingScopeItemsKey] as IScope;
if (scope != null)
{
// NOTE: This event is the start of the result pipeline. The action has been executed, but
// we haven't yet determined which view (if any) will handle the request
object result = _beforeActionResult_ResultFetcher.Fetch(untypedArg);
string resultType = result.GetType().Name;
string operationName = $"Result {resultType}";
var actionResultScope = Tracer.BuildSpan(operationName)
.AsChildOf(scope.Span)
.WithTag(Tags.Component, ResultComponent)
.WithTag(ResultTagType, resultType)
.StartActive();
httpContext.Items[ActionResultScopeItemsKey] = actionResultScope;
}
}
break;
case "Microsoft.AspNetCore.Mvc.AfterActionResult":
{
var httpContext = ((ActionContext)_afterActionResult_actionContextFetcher.Fetch(untypedArg)).HttpContext;
var scope = httpContext.Items[ActionResultScopeItemsKey] as IScope;
if (scope != null)
{
httpContext.Items.Remove(ActionResultScopeItemsKey);
scope.Dispose();
}
}
break;
default:
HandleUnknownEvent(eventName, untypedArg);
break;
}
}
private static string GetDisplayUrl(HttpRequest request)
{
if (request.Host.HasValue)
{
return request.GetDisplayUrl();
}
// HTTP 1.0 requests are not required to provide a Host to be valid
// Since this is just for display, we can provide a string that is
// not an actual Uri with only the fields that are specified.
// request.GetDisplayUrl(), used above, will throw an exception
// if request.Host is null.
return $"{request.Scheme}://{NoHostSpecified}{request.PathBase.Value}{request.Path.Value}{request.QueryString.Value}";
}
private bool ShouldIgnore(HttpContext httpContext)
{
foreach (Func ignore in _options.Hosting.IgnorePatterns)
{
if (ignore(httpContext))
return true;
}
return false;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/AspNetCore/HostingOptions.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
namespace OpenTracing.Contrib.NetCore.AspNetCore
{
public class HostingOptions
{
public const string DefaultComponent = "HttpIn";
// Variables are lazily instantiated to prevent the app from crashing if the required assemblies are not referenced.
private string _componentName = DefaultComponent;
private List> _ignorePatterns;
private Func _operationNameResolver;
///
/// Allows changing the "component" tag of created spans.
///
public string ComponentName
{
get => _componentName;
set => _componentName = value ?? throw new ArgumentNullException(nameof(ComponentName));
}
///
/// A list of delegates that define whether or not a given request should be ignored.
///
/// If any delegate in the list returns true, the request will be ignored.
///
public List> IgnorePatterns
{
get
{
if (_ignorePatterns == null)
{
_ignorePatterns = new List>();
}
return _ignorePatterns;
}
}
///
/// A delegates that defines from which requests tracing headers are extracted.
///
public Func ExtractEnabled { get; set; }
///
/// A delegate that returns the OpenTracing "operation name" for the given request.
///
public Func OperationNameResolver
{
get
{
if (_operationNameResolver == null)
{
_operationNameResolver = (httpContext) => "HTTP " + httpContext.Request.Method;
}
return _operationNameResolver;
}
set => _operationNameResolver = value ?? throw new ArgumentNullException(nameof(OperationNameResolver));
}
///
/// Allows the modification of the created span to e.g. add further tags.
///
public Action OnRequest { get; set; }
///
/// Allows the modification of the created span when error occured to e.g. add further tags.
///
public Action OnError { get; set; }
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/AspNetCore/RequestHeadersExtractAdapter.cs
================================================
using System;
using System.Collections;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using OpenTracing.Propagation;
namespace OpenTracing.Contrib.NetCore.AspNetCore
{
internal sealed class RequestHeadersExtractAdapter : ITextMap
{
private readonly IHeaderDictionary _headers;
public RequestHeadersExtractAdapter(IHeaderDictionary headers)
{
_headers = headers ?? throw new ArgumentNullException(nameof(headers));
}
public void Set(string key, string value)
{
throw new NotSupportedException("This class should only be used with ITracer.Extract");
}
public IEnumerator> GetEnumerator()
{
foreach (var kvp in _headers)
{
yield return new KeyValuePair(kvp.Key, kvp.Value);
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Configuration/DiagnosticOptions.cs
================================================
using System.Collections.Generic;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public abstract class DiagnosticOptions
{
///
/// Defines whether or not generic events from this DiagnostSource should be logged as events.
///
public bool LogEvents { get; set; } = true;
///
/// Defines specific event names that should NOT be logged as events. Set to `false` if you don't want any events to be logged.
///
public HashSet IgnoredEvents { get; } = new HashSet();
///
/// Defines whether or not a span should be created if there is no parent span.
///
public bool StartRootSpans { get; set; } = true;
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Configuration/IOpenTracingBuilder.cs
================================================
namespace Microsoft.Extensions.DependencyInjection
{
///
/// An interface for configuring OpenTracing services.
///
public interface IOpenTracingBuilder
{
///
/// Gets the where OpenTracing services are configured.
///
IServiceCollection Services { get; }
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Configuration/OpenTracingBuilder.cs
================================================
using System;
using Microsoft.Extensions.DependencyInjection;
namespace OpenTracing.Contrib.NetCore.Configuration
{
internal class OpenTracingBuilder : IOpenTracingBuilder
{
public IServiceCollection Services { get; }
public OpenTracingBuilder(IServiceCollection services)
{
Services = services ?? throw new ArgumentNullException(nameof(services));
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Configuration/OpenTracingBuilderExtensions.cs
================================================
using System;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using OpenTracing.Contrib.NetCore.AspNetCore;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.EntityFrameworkCore;
using OpenTracing.Contrib.NetCore.GenericListeners;
using OpenTracing.Contrib.NetCore.HttpHandler;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Contrib.NetCore.Logging;
using OpenTracing.Contrib.NetCore.MicrosoftSqlClient;
using OpenTracing.Contrib.NetCore.SystemSqlClient;
namespace Microsoft.Extensions.DependencyInjection
{
public static class OpenTracingBuilderExtensions
{
internal static IOpenTracingBuilder AddDiagnosticSubscriber(this IOpenTracingBuilder builder)
where TDiagnosticSubscriber : DiagnosticObserver
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton());
return builder;
}
///
/// Adds instrumentation for ASP.NET Core.
///
public static IOpenTracingBuilder AddAspNetCore(this IOpenTracingBuilder builder, Action options = null)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.AddDiagnosticSubscriber();
builder.ConfigureGenericDiagnostics(genericOptions => genericOptions.IgnoredListenerNames.Add(AspNetCoreDiagnostics.DiagnosticListenerName));
// Our default behavior for ASP.NET is that we only want spans if the request itself is traced
builder.ConfigureEntityFrameworkCore(opt => opt.StartRootSpans = false);
builder.ConfigureHttpHandler(opt => opt.StartRootSpans = false);
builder.ConfigureMicrosoftSqlClient(opt => opt.StartRootSpans = false);
builder.ConfigureSystemSqlClient(opt => opt.StartRootSpans = false);
return ConfigureAspNetCore(builder, options);
}
public static IOpenTracingBuilder ConfigureAspNetCore(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
///
/// Adds instrumentation for System.Net.Http.
///
public static IOpenTracingBuilder AddHttpHandler(this IOpenTracingBuilder builder, Action options = null)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.AddDiagnosticSubscriber();
builder.ConfigureGenericDiagnostics(options => options.IgnoredListenerNames.Add(HttpHandlerDiagnostics.DiagnosticListenerName));
return ConfigureHttpHandler(builder, options);
}
public static IOpenTracingBuilder ConfigureHttpHandler(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
///
/// Adds instrumentation for Entity Framework Core.
///
public static IOpenTracingBuilder AddEntityFrameworkCore(this IOpenTracingBuilder builder, Action options = null)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.AddDiagnosticSubscriber();
builder.ConfigureGenericDiagnostics(genericOptions => genericOptions.IgnoredListenerNames.Add(EntityFrameworkCoreDiagnostics.DiagnosticListenerName));
return ConfigureEntityFrameworkCore(builder, options);
}
///
/// Configuration options for the instrumentation of Entity Framework Core.
///
public static IOpenTracingBuilder ConfigureEntityFrameworkCore(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
///
/// Adds instrumentation for generic DiagnosticListeners.
///
public static IOpenTracingBuilder AddGenericDiagnostics(this IOpenTracingBuilder builder, Action options = null)
{
builder.AddDiagnosticSubscriber();
return ConfigureGenericDiagnostics(builder, options);
}
public static IOpenTracingBuilder ConfigureGenericDiagnostics(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
///
/// Disables tracing for all diagnostic listeners that don't have an explicit implementation.
///
public static IOpenTracingBuilder RemoveGenericDiagnostics(this IOpenTracingBuilder builder)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.Services.RemoveAll();
return builder;
}
///
/// Adds instrumentation for Microsoft.Data.SqlClient.
///
public static IOpenTracingBuilder AddMicrosoftSqlClient(this IOpenTracingBuilder builder, Action options = null)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.AddDiagnosticSubscriber();
builder.ConfigureGenericDiagnostics(genericOptions => genericOptions.IgnoredListenerNames.Add(MicrosoftSqlClientDiagnostics.DiagnosticListenerName));
return ConfigureMicrosoftSqlClient(builder, options);
}
///
/// Configuration options for the instrumentation of Microsoft.Data.SqlClient.
///
public static IOpenTracingBuilder ConfigureMicrosoftSqlClient(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
///
/// Adds instrumentation for System.Data.SqlClient.
///
public static IOpenTracingBuilder AddSystemSqlClient(this IOpenTracingBuilder builder, Action options = null)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.AddDiagnosticSubscriber();
builder.ConfigureGenericDiagnostics(options => options.IgnoredListenerNames.Add(SqlClientDiagnostics.DiagnosticListenerName));
return ConfigureSystemSqlClient(builder, options);
}
public static IOpenTracingBuilder ConfigureSystemSqlClient(this IOpenTracingBuilder builder, Action options)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (options != null)
{
builder.Services.Configure(options);
}
return builder;
}
public static IOpenTracingBuilder AddLoggerProvider(this IOpenTracingBuilder builder)
{
if (builder == null)
throw new ArgumentNullException(nameof(builder));
builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton());
builder.Services.Configure(options =>
{
// All interesting request-specific logs are instrumented via DiagnosticSource.
options.AddFilter("Microsoft.AspNetCore.Hosting", LogLevel.None);
// The "Information"-level in ASP.NET Core is too verbose.
options.AddFilter("Microsoft.AspNetCore", LogLevel.Warning);
// EF Core is sending everything to DiagnosticSource AND ILogger so we completely disable the category.
options.AddFilter("Microsoft.EntityFrameworkCore", LogLevel.None);
});
return builder;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Configuration/ServiceCollectionExtensions.cs
================================================
using System;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using OpenTracing;
using OpenTracing.Contrib.NetCore;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Util;
namespace Microsoft.Extensions.DependencyInjection
{
public static class ServiceCollectionExtensions
{
///
/// Adds OpenTracing instrumentation for ASP.NET Core, CoreFx (BCL), Entity Framework Core.
///
public static IServiceCollection AddOpenTracing(this IServiceCollection services, Action builder = null)
{
if (services == null)
throw new ArgumentNullException(nameof(services));
return services.AddOpenTracingCoreServices(otBuilder =>
{
otBuilder.AddLoggerProvider();
otBuilder.AddEntityFrameworkCore();
otBuilder.AddGenericDiagnostics();
otBuilder.AddHttpHandler();
otBuilder.AddMicrosoftSqlClient();
otBuilder.AddSystemSqlClient();
if (AssemblyExists("Microsoft.AspNetCore.Hosting"))
{
otBuilder.AddAspNetCore();
}
builder?.Invoke(otBuilder);
});
}
///
/// Adds the core services required for OpenTracing without any actual instrumentations.
///
public static IServiceCollection AddOpenTracingCoreServices(this IServiceCollection services, Action builder = null)
{
if (services == null)
throw new ArgumentNullException(nameof(services));
services.TryAddSingleton(GlobalTracer.Instance);
services.TryAddSingleton();
services.TryAddSingleton();
services.TryAddEnumerable(ServiceDescriptor.Singleton());
var builderInstance = new OpenTracingBuilder(services);
builder?.Invoke(builderInstance);
return services;
}
private static bool AssemblyExists(string assemblyName)
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
if (assembly.FullName.StartsWith(assemblyName))
return true;
}
return false;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/EntityFrameworkCore/EntityFrameworkCoreDiagnosticOptions.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore.Diagnostics;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public class EntityFrameworkCoreDiagnosticOptions : DiagnosticOptions
{
// NOTE: Everything here that references any EFCore types MUST NOT be initialized in the constructor as that would throw on applications that don't reference EFCore.
public const string DefaultComponent = "EFCore";
private string _componentName = DefaultComponent;
private List> _ignorePatterns;
private Func _operationNameResolver;
public EntityFrameworkCoreDiagnosticOptions()
{
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.StartedTracking");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.DetectChangesStarting");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.DetectChangesCompleted");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.ForeignKeyChangeDetected");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.StateChanged");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.ChangeTracking.ValueGenerated");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Command.CommandCreating");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Command.CommandCreated");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Command.DataReaderDisposing");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Connection.ConnectionOpening");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Connection.ConnectionOpened");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Connection.ConnectionClosing");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Connection.ConnectionClosed");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Transaction.TransactionStarting");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Transaction.TransactionStarted");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Transaction.TransactionCommitting");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Transaction.TransactionCommitted");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Database.Transaction.TransactionDisposed");
IgnoredEvents.Add("Microsoft.EntityFrameworkCore.Infrastructure.ContextDisposed");
}
///
/// A list of delegates that define whether or not a given EF Core command should be ignored.
///
/// If any delegate in the list returns true, the EF Core command will be ignored.
///
public List> IgnorePatterns => _ignorePatterns ??= new List>();
///
/// Allows changing the "component" tag of created spans.
///
public string ComponentName
{
get => _componentName;
set => _componentName = value ?? throw new ArgumentNullException(nameof(ComponentName));
}
///
/// A delegate that returns the OpenTracing "operation name" for the given command.
///
public Func OperationNameResolver
{
get
{
if (_operationNameResolver == null)
{
// Default value may not be set in the constructor because this would fail
// if the target application does not reference EFCore.
_operationNameResolver = (data) => "DB " + data.ExecuteMethod.ToString();
}
return _operationNameResolver;
}
set => _operationNameResolver = value ?? throw new ArgumentNullException(nameof(OperationNameResolver));
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/EntityFrameworkCore/EntityFrameworkCoreDiagnostics.cs
================================================
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore.Diagnostics;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.EntityFrameworkCore
{
internal sealed class EntityFrameworkCoreDiagnostics : DiagnosticEventObserver
{
// https://github.com/aspnet/EntityFrameworkCore/blob/dev/src/EFCore/DbLoggerCategory.cs
public const string DiagnosticListenerName = "Microsoft.EntityFrameworkCore";
private const string TagMethod = "db.method";
private const string TagIsAsync = "db.async";
private readonly EntityFrameworkCoreDiagnosticOptions _options;
private readonly ConcurrentDictionary _scopeStorage;
public EntityFrameworkCoreDiagnostics(ILoggerFactory loggerFactory, ITracer tracer,
IOptions options)
: base(loggerFactory, tracer, options?.Value)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_scopeStorage = new ConcurrentDictionary();
}
protected override string GetListenerName() => DiagnosticListenerName;
protected override IEnumerable HandledEventNames()
{
yield return "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuting";
yield return "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuted";
yield return "Microsoft.EntityFrameworkCore.Database.Command.CommandError";
}
protected override void HandleEvent(string eventName, object untypedArg)
{
switch (eventName)
{
case "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuting":
{
CommandEventData args = (CommandEventData)untypedArg;
var activeSpan = Tracer.ActiveSpan;
if (activeSpan == null && !_options.StartRootSpans)
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring EF command due to missing parent span");
}
return;
}
if (IgnoreEvent(args))
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring EF command due to IgnorePatterns");
}
return;
}
string operationName = _options.OperationNameResolver(args);
var scope = Tracer.BuildSpan(operationName)
.AsChildOf(activeSpan)
.WithTag(Tags.SpanKind, Tags.SpanKindClient)
.WithTag(Tags.Component, _options.ComponentName)
.WithTag(Tags.DbInstance, args.Command.Connection.Database)
.WithTag(Tags.DbStatement, args.Command.CommandText)
.WithTag(TagMethod, args.ExecuteMethod.ToString())
.WithTag(TagIsAsync, args.IsAsync)
.StartActive();
_scopeStorage.TryAdd(args.CommandId, scope);
}
break;
case "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuted":
{
CommandExecutedEventData args = (CommandExecutedEventData)untypedArg;
if (_scopeStorage.TryRemove(args.CommandId, out var scope))
{
scope.Dispose();
}
}
break;
case "Microsoft.EntityFrameworkCore.Database.Command.CommandError":
{
CommandErrorEventData args = (CommandErrorEventData)untypedArg;
// The "CommandExecuted" event is NOT called in case of an exception,
// so we have to dispose the scope here as well!
if (_scopeStorage.TryRemove(args.CommandId, out var scope))
{
scope.Span.SetException(args.Exception);
scope.Dispose();
}
}
break;
default:
{
Dictionary tags = null;
if (untypedArg is EventData eventArgs)
{
tags = new Dictionary
{
{ "level", eventArgs.LogLevel.ToString() },
};
}
HandleUnknownEvent(eventName, untypedArg, tags);
break;
}
}
}
private bool IgnoreEvent(CommandEventData eventData)
{
foreach (Func ignore in _options.IgnorePatterns)
{
if (ignore(eventData))
return true;
}
return false;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/GenericListeners/GenericDiagnosticOptions.cs
================================================
using System.Collections.Generic;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public sealed class GenericDiagnosticOptions
{
public HashSet IgnoredListenerNames { get; } = new HashSet();
public Dictionary> IgnoredEvents { get; } = new Dictionary>();
public void IgnoreEvent(string diagnosticListenerName, string eventName)
{
if (diagnosticListenerName == null || eventName == null)
return;
HashSet ignoredListenerEvents;
if (!IgnoredEvents.TryGetValue(diagnosticListenerName, out ignoredListenerEvents))
{
ignoredListenerEvents = new HashSet();
IgnoredEvents.Add(diagnosticListenerName, ignoredListenerEvents);
}
ignoredListenerEvents.Add(eventName);
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/GenericListeners/GenericDiagnostics.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
namespace OpenTracing.Contrib.NetCore.GenericListeners
{
///
/// A subscriber that logs ALL events to .
///
internal sealed class GenericDiagnostics : DiagnosticObserver
{
private readonly GenericDiagnosticOptions _options;
public GenericDiagnostics(ILoggerFactory loggerFactory, ITracer tracer, IOptions options)
: base(loggerFactory, tracer)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
}
public override IDisposable SubscribeIfMatch(DiagnosticListener diagnosticListener)
{
if (_options.IgnoredListenerNames.Contains(diagnosticListener.Name))
{
return null;
}
_options.IgnoredEvents.TryGetValue(diagnosticListener.Name, out var ignoredListenerEvents);
return new GenericDiagnosticsSubscription(this, diagnosticListener, ignoredListenerEvents);
}
private class GenericDiagnosticsSubscription : IObserver>, IDisposable
{
private readonly GenericDiagnostics _subscriber;
private readonly string _listenerName;
private readonly HashSet _ignoredEvents;
private readonly GenericEventProcessor _genericEventProcessor;
private readonly IDisposable _subscription;
public GenericDiagnosticsSubscription(GenericDiagnostics subscriber, DiagnosticListener diagnosticListener,
HashSet ignoredEvents)
{
_subscriber = subscriber;
_ignoredEvents = ignoredEvents;
_listenerName = diagnosticListener.Name;
_genericEventProcessor = new GenericEventProcessor(_listenerName, _subscriber.Tracer, subscriber.Logger);
_subscription = diagnosticListener.Subscribe(this, IsEnabled);
}
public void Dispose()
{
_subscription.Dispose();
}
private bool IsEnabled(string eventName)
{
if (_ignoredEvents != null && _ignoredEvents.Contains(eventName))
{
if (_subscriber.IsLogLevelTraceEnabled)
{
_subscriber.Logger.LogTrace("Ignoring event '{ListenerName}/{Event}'", _listenerName, eventName);
}
return false;
}
return true;
}
public void OnCompleted()
{
}
public void OnError(Exception error)
{
}
public void OnNext(KeyValuePair value)
{
string eventName = value.Key;
object untypedArg = value.Value;
try
{
// We have to check this twice because EVERY subscriber is called
// if ANY subscriber returns IsEnabled=true.
if (!IsEnabled(eventName))
return;
_genericEventProcessor?.ProcessEvent(eventName, untypedArg);
}
catch (Exception ex)
{
_subscriber.Logger.LogWarning(ex, "Event-Exception: {ListenerName}/{Event}", _listenerName, value.Key);
}
}
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/HttpHandler/HttpHandlerDiagnosticOptions.cs
================================================
using System;
using System.Collections.Generic;
using System.Net.Http;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public class HttpHandlerDiagnosticOptions : DiagnosticOptions
{
public const string PropertyIgnore = "ot-ignore";
public const string DefaultComponent = "HttpOut";
private string _componentName;
private Func _operationNameResolver;
///
/// Allows changing the "component" tag of created spans.
///
public string ComponentName
{
get => _componentName;
set => _componentName = value ?? throw new ArgumentNullException(nameof(ComponentName));
}
///
/// A list of delegates that define whether or not a given request should be ignored.
///
/// If any delegate in the list returns true, the request will be ignored.
///
public List> IgnorePatterns { get; } = new List>();
///
/// A delegates that defines on what requests tracing headers are propagated.
///
public Func InjectEnabled { get; set; }
///
/// A delegate that returns the OpenTracing "operation name" for the given request.
///
public Func OperationNameResolver
{
get => _operationNameResolver;
set => _operationNameResolver = value ?? throw new ArgumentNullException(nameof(OperationNameResolver));
}
///
/// Allows the modification of the created span to e.g. add further tags.
///
public Action OnRequest { get; set; }
///
/// Allows the modification of the created span when error occured to e.g. add further tags.
///
public Action OnError { get; set; }
public HttpHandlerDiagnosticOptions()
{
// Default settings
ComponentName = DefaultComponent;
IgnorePatterns.Add((request) =>
{
IDictionary requestOptions;
#if NETCOREAPP3_1
requestOptions = request.Properties;
#else
requestOptions = request.Options;
#endif
return requestOptions.ContainsKey(PropertyIgnore);
});
OperationNameResolver = (request) =>
{
return "HTTP " + request.Method.Method;
};
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/HttpHandler/HttpHandlerDiagnostics.cs
================================================
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Propagation;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.HttpHandler
{
///
/// Instruments outgoing HTTP calls that use .
/// See https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs
/// and https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/DiagnosticsHandlerLoggingStrings.cs
///
internal sealed class HttpHandlerDiagnostics : DiagnosticEventObserver
{
public const string DiagnosticListenerName = "HttpHandlerDiagnosticListener";
private const string PropertiesKey = "ot-Span";
private static readonly PropertyFetcher _activityStart_RequestFetcher = new PropertyFetcher("Request");
private static readonly PropertyFetcher _activityStop_RequestFetcher = new PropertyFetcher("Request");
private static readonly PropertyFetcher _activityStop_ResponseFetcher = new PropertyFetcher("Response");
private static readonly PropertyFetcher _activityStop_RequestTaskStatusFetcher = new PropertyFetcher("RequestTaskStatus");
private static readonly PropertyFetcher _exception_RequestFetcher = new PropertyFetcher("Request");
private static readonly PropertyFetcher _exception_ExceptionFetcher = new PropertyFetcher("Exception");
private readonly HttpHandlerDiagnosticOptions _options;
public HttpHandlerDiagnostics(ILoggerFactory loggerFactory, ITracer tracer,
IOptions options)
: base(loggerFactory, tracer, options?.Value)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
}
protected override string GetListenerName() => DiagnosticListenerName;
protected override bool IsSupportedEvent(string eventName)
{
return eventName switch
{
// We don't want to get the old deprecated events.
// https://github.com/dotnet/runtime/blob/master/src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandlerLoggingStrings.cs
"System.Net.Http.Request" => false,
"System.Net.Http.Response" => false,
_ => true,
};
}
protected override IEnumerable HandledEventNames()
{
yield return "System.Net.Http.HttpRequestOut.Start";
yield return "System.Net.Http.Exception";
yield return "System.Net.Http.HttpRequestOut.Stop";
}
protected override void HandleEvent(string eventName, object untypedArg)
{
switch (eventName)
{
case "System.Net.Http.HttpRequestOut.Start":
{
var request = (HttpRequestMessage)_activityStart_RequestFetcher.Fetch(untypedArg);
var activeSpan = Tracer.ActiveSpan;
if (activeSpan == null && !_options.StartRootSpans)
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring Request due to missing parent span");
}
return;
}
if (IgnoreRequest(request))
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring Request {RequestUri}", request.RequestUri);
}
return;
}
string operationName = _options.OperationNameResolver(request);
ISpan span = Tracer.BuildSpan(operationName)
.AsChildOf(activeSpan)
.WithTag(Tags.SpanKind, Tags.SpanKindClient)
.WithTag(Tags.Component, _options.ComponentName)
.WithTag(Tags.HttpMethod, request.Method.ToString())
.WithTag(Tags.HttpUrl, request.RequestUri.ToString())
.WithTag(Tags.PeerHostname, request.RequestUri.Host)
.WithTag(Tags.PeerPort, request.RequestUri.Port)
.Start();
_options.OnRequest?.Invoke(span, request);
if (_options.InjectEnabled?.Invoke(request) ?? true)
{
Tracer.Inject(span.Context, BuiltinFormats.HttpHeaders, new HttpHeadersInjectAdapter(request.Headers));
}
var requestOptions = GetRequestOptions(request);
requestOptions[PropertiesKey] = span;
}
break;
case "System.Net.Http.Exception":
{
var request = (HttpRequestMessage)_exception_RequestFetcher.Fetch(untypedArg);
var requestOptions = GetRequestOptions(request);
if (requestOptions.TryGetValue(PropertiesKey, out object objSpan) && objSpan is ISpan span)
{
var exception = (Exception)_exception_ExceptionFetcher.Fetch(untypedArg);
span.SetException(exception);
_options.OnError?.Invoke(span, exception, request);
}
}
break;
case "System.Net.Http.HttpRequestOut.Stop":
{
var request = (HttpRequestMessage)_activityStop_RequestFetcher.Fetch(untypedArg);
var requestOptions = GetRequestOptions(request);
if (requestOptions.TryGetValue(PropertiesKey, out object objSpan) && objSpan is ISpan span)
{
requestOptions.Remove(PropertiesKey);
var response = (HttpResponseMessage)_activityStop_ResponseFetcher.Fetch(untypedArg);
var requestTaskStatus = (TaskStatus)_activityStop_RequestTaskStatusFetcher.Fetch(untypedArg);
if (response != null)
{
span.SetTag(Tags.HttpStatus, (int)response.StatusCode);
}
if (requestTaskStatus == TaskStatus.Canceled || requestTaskStatus == TaskStatus.Faulted)
{
span.SetTag(Tags.Error, true);
}
span.Finish();
}
}
break;
default:
HandleUnknownEvent(eventName, untypedArg);
break;
}
}
private bool IgnoreRequest(HttpRequestMessage request)
{
foreach (Func ignore in _options.IgnorePatterns)
{
if (ignore(request))
return true;
}
return false;
}
private IDictionary GetRequestOptions(HttpRequestMessage request)
{
IDictionary requestOptions;
#if NETCOREAPP3_1
requestOptions = request.Properties;
#else
requestOptions = request.Options;
#endif
return requestOptions;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/HttpHandler/HttpHeadersInjectAdapter.cs
================================================
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net.Http.Headers;
using OpenTracing.Propagation;
namespace OpenTracing.Contrib.NetCore.HttpHandler
{
internal sealed class HttpHeadersInjectAdapter : ITextMap
{
private readonly HttpHeaders _headers;
public HttpHeadersInjectAdapter(HttpHeaders headers)
{
_headers = headers ?? throw new ArgumentNullException(nameof(headers));
}
public void Set(string key, string value)
{
if (_headers.Contains(key))
{
_headers.Remove(key);
}
_headers.Add(key, value);
}
public IEnumerator> GetEnumerator()
{
throw new NotSupportedException("This class should only be used with ITracer.Inject");
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/InstrumentationService.cs
================================================
using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using OpenTracing.Contrib.NetCore.Internal;
namespace OpenTracing.Contrib.NetCore
{
///
/// Starts and stops all OpenTracing instrumentation components.
///
internal class InstrumentationService : IHostedService
{
private readonly DiagnosticManager _diagnosticsManager;
public InstrumentationService(DiagnosticManager diagnosticManager)
{
_diagnosticsManager = diagnosticManager ?? throw new ArgumentNullException(nameof(diagnosticManager));
}
public Task StartAsync(CancellationToken cancellationToken)
{
_diagnosticsManager.Start();
return Task.CompletedTask;
}
public Task StopAsync(CancellationToken cancellationToken)
{
_diagnosticsManager.Stop();
return Task.CompletedTask;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/DiagnosticEventObserver.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using OpenTracing.Contrib.NetCore.Configuration;
namespace OpenTracing.Contrib.NetCore.Internal
{
///
/// Base class that allows handling events from a single .
///
internal abstract class DiagnosticEventObserver
: DiagnosticObserver, IObserver>
{
private readonly DiagnosticOptions _options;
private readonly GenericEventProcessor _genericEventProcessor;
protected DiagnosticEventObserver(ILoggerFactory loggerFactory, ITracer tracer, DiagnosticOptions options)
: base(loggerFactory, tracer)
{
_options = options;
if (options.LogEvents)
{
_genericEventProcessor = new GenericEventProcessor(GetListenerName(), Tracer, Logger);
}
}
public override IDisposable SubscribeIfMatch(DiagnosticListener diagnosticListener)
{
if (diagnosticListener.Name == GetListenerName())
{
return diagnosticListener.Subscribe(this, IsEnabled);
}
return null;
}
void IObserver>.OnCompleted()
{
}
void IObserver>.OnError(Exception error)
{
}
void IObserver>.OnNext(KeyValuePair value)
{
try
{
if (IsEnabled(value.Key))
{
HandleEvent(value.Key, value.Value);
}
}
catch (Exception ex)
{
Logger.LogWarning(ex, "Event-Exception: {Event}", value.Key);
}
}
///
/// The name of the that should be instrumented.
///
protected abstract string GetListenerName();
protected virtual bool IsSupportedEvent(string eventName) => true;
protected abstract IEnumerable HandledEventNames();
private bool IsEnabled(string eventName)
{
if (!IsSupportedEvent(eventName))
return false;
foreach (var handledEventName in HandledEventNames())
{
if (handledEventName == eventName)
return true;
}
if (!_options.LogEvents || _options.IgnoredEvents.Contains(eventName))
return false;
return true;
}
protected abstract void HandleEvent(string eventName, object untypedArg);
protected void HandleUnknownEvent(string eventName, object untypedArg, IEnumerable> tags = null)
{
_genericEventProcessor?.ProcessEvent(eventName, untypedArg, tags);
}
protected void DisposeActiveScope(bool isScopeRequired, Exception exception = null)
{
IScope scope = Tracer.ScopeManager.Active;
if (scope != null)
{
if (exception != null)
{
scope.Span.SetException(exception);
}
scope.Dispose();
}
else if (isScopeRequired)
{
Logger.LogWarning("Scope not found");
}
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/DiagnosticManager.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace OpenTracing.Contrib.NetCore.Internal
{
///
/// Subscribes to and forwards events to individual instances.
///
internal sealed class DiagnosticManager : IObserver, IDisposable
{
private readonly ILogger _logger;
private readonly ITracer _tracer;
private readonly IEnumerable _diagnosticSubscribers;
private readonly DiagnosticManagerOptions _options;
private readonly List _subscriptions = new List();
private IDisposable _allListenersSubscription;
public bool IsRunning => _allListenersSubscription != null;
public DiagnosticManager(
ILoggerFactory loggerFactory,
ITracer tracer,
IEnumerable diagnosticSubscribers,
IOptions options)
{
if (loggerFactory == null)
throw new ArgumentNullException(nameof(loggerFactory));
if (diagnosticSubscribers == null)
throw new ArgumentNullException(nameof(diagnosticSubscribers));
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_logger = loggerFactory.CreateLogger();
_diagnosticSubscribers = diagnosticSubscribers;
}
public void Start()
{
if (_allListenersSubscription == null)
{
if (_tracer.IsNoopTracer() && !_options.StartInstrumentationForNoopTracer)
{
_logger.LogWarning("Instrumentation has not been started because no tracer was registered.");
}
else
{
_logger.LogTrace("Starting AllListeners subscription");
_allListenersSubscription = DiagnosticListener.AllListeners.Subscribe(this);
}
}
}
void IObserver.OnCompleted()
{
}
void IObserver.OnError(Exception error)
{
}
void IObserver.OnNext(DiagnosticListener listener)
{
foreach (var subscriber in _diagnosticSubscribers)
{
IDisposable subscription = subscriber.SubscribeIfMatch(listener);
if (subscription != null)
{
_logger.LogTrace($"Subscriber '{subscriber.GetType().Name}' returned subscription for '{listener.Name}'");
_subscriptions.Add(subscription);
}
}
}
public void Stop()
{
if (_allListenersSubscription != null)
{
_logger.LogTrace("Stopping AllListeners subscription");
_allListenersSubscription.Dispose();
_allListenersSubscription = null;
foreach (var subscription in _subscriptions)
{
subscription.Dispose();
}
_subscriptions.Clear();
}
}
public void Dispose()
{
Stop();
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/DiagnosticManagerOptions.cs
================================================
namespace OpenTracing.Contrib.NetCore.Internal
{
public class DiagnosticManagerOptions
{
public bool StartInstrumentationForNoopTracer { get; set; }
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/DiagnosticObserver.cs
================================================
using System;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
namespace OpenTracing.Contrib.NetCore.Internal
{
internal abstract class DiagnosticObserver
{
protected ILogger Logger { get; }
protected ITracer Tracer { get; }
protected bool IsLogLevelTraceEnabled { get; }
protected DiagnosticObserver(ILoggerFactory loggerFactory, ITracer tracer)
{
if (loggerFactory == null)
throw new ArgumentNullException(nameof(loggerFactory));
if (tracer == null)
throw new ArgumentNullException(nameof(tracer));
Logger = loggerFactory.CreateLogger(GetType());
Tracer = tracer;
IsLogLevelTraceEnabled = Logger.IsEnabled(LogLevel.Trace);
}
public abstract IDisposable SubscribeIfMatch(DiagnosticListener diagnosticListener);
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/GenericEventProcessor.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.Internal
{
internal class GenericEventProcessor
{
private readonly string _listenerName;
private readonly ITracer _tracer;
private readonly ILogger _logger;
private readonly bool _isLogLevelTraceEnabled;
public GenericEventProcessor(string listenerName, ITracer tracer, ILogger logger)
{
_listenerName = listenerName ?? throw new ArgumentNullException(nameof(listenerName));
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_isLogLevelTraceEnabled = _logger.IsEnabled(LogLevel.Trace);
}
public void ProcessEvent(string eventName, object untypedArg, IEnumerable> tags = null)
{
Activity activity = Activity.Current;
if (activity != null && eventName.EndsWith(".Start", StringComparison.Ordinal))
{
HandleActivityStart(eventName, activity, untypedArg, tags);
}
else if (activity != null && eventName.EndsWith(".Stop", StringComparison.Ordinal))
{
HandleActivityStop(eventName, activity);
}
else
{
HandleRegularEvent(eventName, untypedArg, tags);
}
}
private void HandleActivityStart(string eventName, Activity activity, object untypedArg, IEnumerable> tags)
{
ISpanBuilder spanBuilder = _tracer.BuildSpan(activity.OperationName)
.WithTag(Tags.Component, _listenerName);
foreach (var tag in activity.Tags)
{
spanBuilder.WithTag(tag.Key, tag.Value);
}
if (tags != null)
{
foreach (var tag in tags)
{
spanBuilder.WithTag(tag.Key, tag.Value);
}
}
spanBuilder.StartActive();
}
private void HandleActivityStop(string eventName, Activity activity)
{
IScope scope = _tracer.ScopeManager.Active;
if (scope != null)
{
scope.Dispose();
}
else
{
_logger.LogWarning("No scope found. Event: {ListenerName}/{Event}", _listenerName, eventName);
}
}
private void HandleRegularEvent(string eventName, object untypedArg, IEnumerable> tags)
{
var span = _tracer.ActiveSpan;
if (span != null)
{
span.Log(GetLogFields(eventName, untypedArg, tags));
}
else if (_isLogLevelTraceEnabled)
{
_logger.LogTrace("No ActiveSpan. Event: {ListenerName}/{Event}", _listenerName, eventName);
}
}
private Dictionary GetLogFields(string eventName, object arg, IEnumerable> tags)
{
var fields = new Dictionary
{
{ LogFields.Event, eventName },
{ Tags.Component.Key, _listenerName }
};
if (tags != null)
{
foreach (var tag in tags)
{
fields[tag.Key] = tag.Value;
}
}
// TODO improve the hell out of this... :)
if (arg != null)
{
Type argType = arg.GetType();
if (argType.IsPrimitive)
{
fields.Add("arg", arg);
}
else if (argType.Namespace == null)
{
// Anonymous types usually contain complex objects so their output is not really useful.
// Ignoring them for now.
}
else
{
fields.Add("arg", arg.ToString());
if (_isLogLevelTraceEnabled)
{
_logger.LogTrace("Can not extract value for argument type '{Type}'. Using ToString()", argType);
}
}
}
return fields;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/GlobalTracerAccessor.cs
================================================
using OpenTracing.Util;
namespace OpenTracing.Contrib.NetCore.Internal
{
public class GlobalTracerAccessor : IGlobalTracerAccessor
{
public ITracer GetGlobalTracer()
{
return GlobalTracer.Instance;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/IGlobalTracerAccessor.cs
================================================
namespace OpenTracing.Contrib.NetCore.Internal
{
///
/// Helper interface which allows unit tests to mock the .
///
public interface IGlobalTracerAccessor
{
ITracer GetGlobalTracer();
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/PropertyFetcher.cs
================================================
// From https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs
using System;
using System.Linq;
using System.Reflection;
namespace OpenTracing.Contrib.NetCore.Internal
{
internal class PropertyFetcher
{
private readonly string _propertyName;
private Type _expectedType;
private PropertyFetch _fetchForExpectedType;
///
/// Make a new PropertyFetcher for a property named 'propertyName'.
///
public PropertyFetcher(string propertyName)
{
_propertyName = propertyName;
}
///
/// Given an object fetch the property that this PropertySpec represents.
///
public object Fetch(object obj)
{
Type objType = obj.GetType();
if (objType != _expectedType)
{
TypeInfo typeInfo = objType.GetTypeInfo();
var propertyInfo = typeInfo.DeclaredProperties.FirstOrDefault(p => string.Equals(p.Name, _propertyName, StringComparison.InvariantCultureIgnoreCase));
_fetchForExpectedType = PropertyFetch.FetcherForProperty(propertyInfo);
_expectedType = objType;
}
return _fetchForExpectedType.Fetch(obj);
}
///
/// PropertyFetch is a helper class. It takes a PropertyInfo and then knows how
/// to efficiently fetch that property from a .NET object (See Fetch method).
/// It hides some slightly complex generic code.
///
private class PropertyFetch
{
///
/// Create a property fetcher from a .NET Reflection PropertyInfo class that
/// represents a property of a particular type.
///
public static PropertyFetch FetcherForProperty(PropertyInfo propertyInfo)
{
if (propertyInfo == null)
return new PropertyFetch(); // returns null on any fetch.
Type typedPropertyFetcher = typeof(TypedFetchProperty<,>);
Type instantiatedTypedPropertyFetcher = typedPropertyFetcher.GetTypeInfo().MakeGenericType(
propertyInfo.DeclaringType, propertyInfo.PropertyType);
return (PropertyFetch)Activator.CreateInstance(instantiatedTypedPropertyFetcher, propertyInfo);
}
///
/// Given an object, fetch the property that this propertyFech represents.
///
public virtual object Fetch(object obj)
{
return null;
}
private class TypedFetchProperty : PropertyFetch
{
public TypedFetchProperty(PropertyInfo property)
{
_propertyFetch = (Func)property.GetMethod.CreateDelegate(typeof(Func));
}
public override object Fetch(object obj)
{
return _propertyFetch((TObject)obj);
}
private readonly Func _propertyFetch;
}
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/SpanExtensions.cs
================================================
using System;
using System.Collections.Generic;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.Internal
{
internal static class SpanExtensions
{
///
/// Sets the tag and adds information about the
/// to the given .
///
public static void SetException(this ISpan span, Exception exception)
{
if (span == null || exception == null)
return;
span.SetTag(Tags.Error, true);
span.Log(new Dictionary(3)
{
{ LogFields.Event, Tags.Error.Key },
{ LogFields.ErrorKind, exception.GetType().Name },
{ LogFields.ErrorObject, exception }
});
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Internal/TracerExtensions.cs
================================================
using OpenTracing.Noop;
using OpenTracing.Util;
namespace OpenTracing.Contrib.NetCore.Internal
{
internal static class TracerExtensions
{
public static bool IsNoopTracer(this ITracer tracer)
{
if (tracer is NoopTracer)
return true;
// There's no way to check the underlying tracer on the instance so we have to check the static method.
if (tracer is GlobalTracer && !GlobalTracer.IsRegistered())
return true;
return false;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Logging/OpenTracingLogger.cs
================================================
using System;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Noop;
using OpenTracing.Util;
namespace OpenTracing.Contrib.NetCore.Logging
{
internal class OpenTracingLogger : ILogger
{
private const string OriginalFormatPropertyName = "{OriginalFormat}";
private readonly string _categoryName;
private readonly IGlobalTracerAccessor _globalTracerAccessor;
public OpenTracingLogger(IGlobalTracerAccessor globalTracerAccessor, string categoryName)
{
_globalTracerAccessor = globalTracerAccessor;
_categoryName = categoryName;
}
public IDisposable BeginScope(TState state)
{
return NoopDisposable.Instance;
}
public bool IsEnabled(LogLevel logLevel)
{
// Filtering should be done via the general Logging filtering feature.
ITracer tracer = _globalTracerAccessor.GetGlobalTracer();
return !(
(tracer is NoopTracer) ||
(tracer is GlobalTracer && !GlobalTracer.IsRegistered()));
}
public void Log(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func formatter)
{
if (formatter == null)
{
// This throws an Exception e.g. in Microsoft's DebugLogger but we don't want the app to crash if the logger has an issue.
return;
}
ITracer tracer = _globalTracerAccessor.GetGlobalTracer();
ISpan span = tracer.ActiveSpan;
if (span == null)
{
// Creating a new span for a log message seems brutal so we ignore messages if we can't attach it to an active span.
return;
}
if (!IsEnabled(logLevel))
{
return;
}
var fields = new Dictionary
{
{ "component", _categoryName },
{ "level", logLevel.ToString() }
};
try
{
if (eventId.Id != 0)
{
fields["eventId"] = eventId.Id;
}
try
{
// This throws if the argument count (message format vs. actual args) doesn't match.
// e.g. LogInformation("Foo {Arg1} {Arg2}", arg1);
// We want to preserve as much as possible from the original log message so we just continue without this information.
string message = formatter(state, exception);
fields[LogFields.Message] = message;
}
catch (Exception)
{
/* no-op */
}
if (exception != null)
{
fields[LogFields.ErrorKind] = exception.GetType().FullName;
fields[LogFields.ErrorObject] = exception;
}
bool eventAdded = false;
var structure = state as IEnumerable>;
if (structure != null)
{
try
{
// The enumerator throws if the argument count (message format vs. actual args) doesn't match.
// We want to preserve as much as possible from the original log message so we just ignore
// this error and take as many properties as possible.
foreach (var property in structure)
{
if (string.Equals(property.Key, OriginalFormatPropertyName, StringComparison.Ordinal)
&& property.Value is string messageTemplateString)
{
fields[LogFields.Event] = messageTemplateString;
eventAdded = true;
}
else
{
fields[property.Key] = property.Value;
}
}
}
catch (IndexOutOfRangeException)
{
/* no-op */
}
}
if (!eventAdded)
{
fields[LogFields.Event] = "log";
}
}
catch (Exception logException)
{
fields["opentracing.contrib.netcore.error"] = logException.ToString();
}
span.Log(fields);
}
private class NoopDisposable : IDisposable
{
public static NoopDisposable Instance = new NoopDisposable();
public void Dispose()
{
}
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/Logging/OpenTracingLoggerProvider.cs
================================================
using System;
using Microsoft.Extensions.Logging;
using OpenTracing.Contrib.NetCore.Internal;
namespace OpenTracing.Contrib.NetCore.Logging
{
///
/// The provider for the .
///
[ProviderAlias("OpenTracing")]
internal class OpenTracingLoggerProvider : ILoggerProvider
{
private readonly IGlobalTracerAccessor _globalTracerAccessor;
public OpenTracingLoggerProvider(IGlobalTracerAccessor globalTracerAccessor)
{
_globalTracerAccessor = globalTracerAccessor ?? throw new ArgumentNullException(nameof(globalTracerAccessor));
}
///
public ILogger CreateLogger(string categoryName)
{
return new OpenTracingLogger(_globalTracerAccessor, categoryName);
}
public void Dispose()
{
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/MicrosoftSqlClient/MicrosoftSqlClientDiagnosticOptions.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Data.SqlClient;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public class MicrosoftSqlClientDiagnosticOptions : DiagnosticOptions
{
public static class EventNames
{
// https://github.com/dotnet/SqlClient/blob/master/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlClientDiagnosticListenerExtensions.cs
private const string SqlClientPrefix = "Microsoft.Data.SqlClient.";
public const string WriteCommandBefore = SqlClientPrefix + nameof(WriteCommandBefore);
public const string WriteCommandAfter = SqlClientPrefix + nameof(WriteCommandAfter);
public const string WriteCommandError = SqlClientPrefix + nameof(WriteCommandError);
public const string WriteConnectionOpenBefore = SqlClientPrefix + nameof(WriteConnectionOpenBefore);
public const string WriteConnectionOpenAfter = SqlClientPrefix + nameof(WriteConnectionOpenAfter);
public const string WriteConnectionOpenError = SqlClientPrefix + nameof(WriteConnectionOpenError);
public const string WriteConnectionCloseBefore = SqlClientPrefix + nameof(WriteConnectionCloseBefore);
public const string WriteConnectionCloseAfter = SqlClientPrefix + nameof(WriteConnectionCloseAfter);
public const string WriteConnectionCloseError = SqlClientPrefix + nameof(WriteConnectionCloseError);
public const string WriteTransactionCommitBefore = SqlClientPrefix + nameof(WriteTransactionCommitBefore);
public const string WriteTransactionCommitAfter = SqlClientPrefix + nameof(WriteTransactionCommitAfter);
public const string WriteTransactionCommitError = SqlClientPrefix + nameof(WriteTransactionCommitError);
public const string WriteTransactionRollbackBefore = SqlClientPrefix + nameof(WriteTransactionRollbackBefore);
public const string WriteTransactionRollbackAfter = SqlClientPrefix + nameof(WriteTransactionRollbackAfter);
public const string WriteTransactionRollbackError = SqlClientPrefix + nameof(WriteTransactionRollbackError);
}
public const string DefaultComponent = "SqlClient";
public const string SqlClientPrefix = "sqlClient ";
private string _componentName = DefaultComponent;
private List> _ignorePatterns;
private Func _operationNameResolver;
///
/// A list of delegates that define whether or not a given SQL command should be ignored.
///
/// If any delegate in the list returns true, the SQL command will be ignored.
///
public List> IgnorePatterns => _ignorePatterns ??= new List>();
///
/// Allows changing the "component" tag of created spans.
///
public string ComponentName
{
get => _componentName;
set => _componentName = value ?? throw new ArgumentNullException(nameof(ComponentName));
}
///
/// A delegate that returns the OpenTracing "operation name" for the given command.
///
public Func OperationNameResolver
{
get
{
if (_operationNameResolver == null)
{
// Default value may not be set in the constructor because this would fail
// if the target application does not reference SqlClient.
_operationNameResolver = (cmd) =>
{
var commandType = cmd.CommandText?.Split(' ');
return $"{SqlClientPrefix}{commandType?.FirstOrDefault()}";
};
}
return _operationNameResolver;
}
set => _operationNameResolver = value ?? throw new ArgumentNullException(nameof(OperationNameResolver));
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/MicrosoftSqlClient/MicrosoftSqlClientDiagnostics.cs
================================================
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.MicrosoftSqlClient
{
internal sealed class MicrosoftSqlClientDiagnostics : DiagnosticEventObserver
{
public const string DiagnosticListenerName = "SqlClientDiagnosticListener";
private static readonly PropertyFetcher _activityCommand_RequestFetcher = new PropertyFetcher("Command");
private static readonly PropertyFetcher _exception_ExceptionFetcher = new PropertyFetcher("Exception");
private readonly MicrosoftSqlClientDiagnosticOptions _options;
private readonly ConcurrentDictionary _spanStorage;
public MicrosoftSqlClientDiagnostics(ILoggerFactory loggerFactory, ITracer tracer, IOptions options)
: base(loggerFactory, tracer, options?.Value)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_spanStorage = new ConcurrentDictionary();
}
protected override string GetListenerName() => DiagnosticListenerName;
///
/// Both diagnostic listeners for System.Data.SqlClient and Microsoft.Data.SqlClient use the same listener name,
/// so we need to make sure this observer gets the correct events.
///
protected override bool IsSupportedEvent(string eventName) => eventName.StartsWith("Microsoft.");
protected override IEnumerable HandledEventNames()
{
yield return MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandBefore;
yield return MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandError;
yield return MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandAfter;
}
protected override void HandleEvent(string eventName, object untypedArg)
{
switch (eventName)
{
case MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandBefore:
{
var cmd = (SqlCommand)_activityCommand_RequestFetcher.Fetch(untypedArg);
var activeSpan = Tracer.ActiveSpan;
if (activeSpan == null && !_options.StartRootSpans)
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring SQL command due to missing parent span");
}
return;
}
if (IgnoreEvent(cmd))
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring SQL command due to IgnorePatterns");
}
return;
}
string operationName = _options.OperationNameResolver(cmd);
var span = Tracer.BuildSpan(operationName)
.AsChildOf(activeSpan)
.WithTag(Tags.SpanKind, Tags.SpanKindClient)
.WithTag(Tags.Component, _options.ComponentName)
.WithTag(Tags.DbInstance, cmd.Connection.Database)
.WithTag(Tags.DbStatement, cmd.CommandText)
.Start();
_spanStorage.TryAdd(cmd, span);
}
break;
case MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandError:
{
var cmd = (SqlCommand)_activityCommand_RequestFetcher.Fetch(untypedArg);
var ex = (Exception)_exception_ExceptionFetcher.Fetch(untypedArg);
if (_spanStorage.TryRemove(cmd, out var span))
{
span.SetException(ex);
span.Finish();
}
}
break;
case MicrosoftSqlClientDiagnosticOptions.EventNames.WriteCommandAfter:
{
var cmd = (SqlCommand)_activityCommand_RequestFetcher.Fetch(untypedArg);
if (_spanStorage.TryRemove(cmd, out var span))
{
span.Finish();
}
}
break;
default:
HandleUnknownEvent(eventName, untypedArg);
break;
}
}
private bool IgnoreEvent(SqlCommand sqlCommand)
{
foreach (Func ignore in _options.IgnorePatterns)
{
if (ignore(sqlCommand))
return true;
}
return false;
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/OpenTracing.Contrib.NetCore.csproj
================================================
netcoreapp3.1;net6.0;net7.0
Adds OpenTracing instrumentation for .NET Core apps that use the `Microsoft.Extensions.*` stack.
Instrumented components: HttpClient calls, ASP.NET Core, Entity Framework Core and any other library that uses DiagnosticSource events.
opentracing;distributed-tracing;tracing;netcore
================================================
FILE: src/OpenTracing.Contrib.NetCore/Properties/AssemblyInfo.cs
================================================
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("OpenTracing.Contrib.NetCore.Tests, PublicKey=" +
"00240000048000009400000006020000002400005253413100040000010001005d933a901e4687" +
"a5fad68c57b11f12b925922968cb9b7c4ef5744b4e3c7d7535095fb13a87169a4dde0ef547a035" +
"0089ae94e192dfeddfa8272b12a76cd42bd36d8b7003bfff49bc825c1a9d510b3c37549efac581" +
"0194d6cfdac8c4dc2f465e4c893a32b65a2f2d55faa3d24d6e68d861a7ccdec74d80ccf03b4489" +
"f51328ba")]
[assembly: InternalsVisibleTo("OpenTracing.Contrib.NetCore.Benchmarks, PublicKey=" +
"00240000048000009400000006020000002400005253413100040000010001005d933a901e4687" +
"a5fad68c57b11f12b925922968cb9b7c4ef5744b4e3c7d7535095fb13a87169a4dde0ef547a035" +
"0089ae94e192dfeddfa8272b12a76cd42bd36d8b7003bfff49bc825c1a9d510b3c37549efac581" +
"0194d6cfdac8c4dc2f465e4c893a32b65a2f2d55faa3d24d6e68d861a7ccdec74d80ccf03b4489" +
"f51328ba")]
================================================
FILE: src/OpenTracing.Contrib.NetCore/SystemSqlClient/SqlClientDiagnosticOptions.cs
================================================
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
namespace OpenTracing.Contrib.NetCore.Configuration
{
public class SqlClientDiagnosticOptions : DiagnosticOptions
{
public const string DefaultComponent = "SqlClient";
public const string SqlClientPrefix = "sqlClient ";
private string _componentName = DefaultComponent;
private List> _ignorePatterns;
private Func _operationNameResolver;
///
/// A list of delegates that define whether or not a given SQL command should be ignored.
///
/// If any delegate in the list returns true, the SQL command will be ignored.
///
public List> IgnorePatterns => _ignorePatterns ??= new List>();
///
/// Allows changing the "component" tag of created spans.
///
public string ComponentName
{
get => _componentName;
set => _componentName = value ?? throw new ArgumentNullException(nameof(ComponentName));
}
///
/// A delegate that returns the OpenTracing "operation name" for the given command.
///
public Func OperationNameResolver
{
get
{
if (_operationNameResolver == null)
{
// Default value may not be set in the constructor because this would fail
// if the target application does not reference SqlClient.
_operationNameResolver = (cmd) =>
{
var commandType = cmd.CommandText?.Split(' ');
return $"{SqlClientPrefix}{commandType?.FirstOrDefault()}";
};
}
return _operationNameResolver;
}
set => _operationNameResolver = value ?? throw new ArgumentNullException(nameof(OperationNameResolver));
}
}
}
================================================
FILE: src/OpenTracing.Contrib.NetCore/SystemSqlClient/SqlClientDiagnostics.cs
================================================
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data.SqlClient;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Tag;
namespace OpenTracing.Contrib.NetCore.SystemSqlClient
{
internal sealed class SqlClientDiagnostics : DiagnosticEventObserver
{
public const string DiagnosticListenerName = "SqlClientDiagnosticListener";
private static readonly PropertyFetcher _writeCommandBefore_CommandFetcher = new PropertyFetcher("Command");
private static readonly PropertyFetcher _writeCommandError_CommandFetcher = new PropertyFetcher("Command");
private static readonly PropertyFetcher _writeCommandAfter_CommandFetcher = new PropertyFetcher("Command");
private static readonly PropertyFetcher _exception_ExceptionFetcher = new PropertyFetcher("Exception");
private readonly SqlClientDiagnosticOptions _options;
private readonly ConcurrentDictionary _spanStorage;
public SqlClientDiagnostics(ILoggerFactory loggerFactory, ITracer tracer, IOptions options)
: base(loggerFactory, tracer, options?.Value)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_spanStorage = new ConcurrentDictionary();
}
protected override string GetListenerName() => DiagnosticListenerName;
///
/// Both diagnostic listeners for System.Data.SqlClient and Microsoft.Data.SqlClient use the same listener name,
/// so we need to make sure this observer gets the correct events.
///
protected override bool IsSupportedEvent(string eventName) => eventName.StartsWith("System.");
protected override IEnumerable HandledEventNames()
{
yield return "System.Data.SqlClient.WriteCommandBefore";
yield return "System.Data.SqlClient.WriteCommandError";
yield return "System.Data.SqlClient.WriteCommandAfter";
}
protected override void HandleEvent(string eventName, object untypedArg)
{
switch (eventName)
{
case "System.Data.SqlClient.WriteCommandBefore":
{
var cmd = (SqlCommand)_writeCommandBefore_CommandFetcher.Fetch(untypedArg);
var activeSpan = Tracer.ActiveSpan;
if (activeSpan == null && !_options.StartRootSpans)
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring SQL command due to missing parent span");
}
return;
}
if (IgnoreEvent(cmd))
{
if (IsLogLevelTraceEnabled)
{
Logger.LogTrace("Ignoring SQL command due to IgnorePatterns");
}
return;
}
string operationName = _options.OperationNameResolver(cmd);
var span = Tracer.BuildSpan(operationName)
.AsChildOf(activeSpan)
.WithTag(Tags.SpanKind, Tags.SpanKindClient)
.WithTag(Tags.Component, _options.ComponentName)
.WithTag(Tags.DbInstance, cmd.Connection.Database)
.WithTag(Tags.DbStatement, cmd.CommandText)
.Start();
_spanStorage.TryAdd(cmd, span);
}
break;
case "System.Data.SqlClient.WriteCommandError":
{
var cmd = (SqlCommand)_writeCommandError_CommandFetcher.Fetch(untypedArg);
var ex = (Exception)_exception_ExceptionFetcher.Fetch(untypedArg);
if (_spanStorage.TryRemove(cmd, out var span))
{
span.SetException(ex);
span.Finish();
}
}
break;
case "System.Data.SqlClient.WriteCommandAfter":
{
var cmd = (SqlCommand)_writeCommandAfter_CommandFetcher.Fetch(untypedArg);
if (_spanStorage.TryRemove(cmd, out var span))
{
span.Finish();
}
}
break;
default:
HandleUnknownEvent(eventName, untypedArg);
break;
}
}
private bool IgnoreEvent(SqlCommand sqlCommand)
{
foreach (Func ignore in _options.IgnorePatterns)
{
if (ignore(sqlCommand))
return true;
}
return false;
}
}
}
================================================
FILE: test/OpenTracing.Contrib.NetCore.Tests/AspNetCore/HostingTest.cs
================================================
using System;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.AspNetCore;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Mock;
using OpenTracing.Tag;
using Xunit;
using Xunit.Abstractions;
namespace OpenTracing.Contrib.NetCore.Tests.AspNetCore
{
public class TestProgramFactory : WebApplicationFactory
{
protected override IWebHostBuilder CreateWebHostBuilder()
{
var host = WebHost.CreateDefaultBuilder()
// https://stackoverflow.com/a/69776251/5214796
.UseSetting("TEST_CONTENTROOT_OPENTRACING_CONTRIB_NETCORE_TESTS", "")
.ConfigureServices(services =>
{
})
.Configure(app =>
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/foo", async context =>
{
await context.Response.WriteAsync("Hello");
});
endpoints.MapGet("/exception", _ =>
{
throw new InvalidOperationException("You shall not pass");
});
});
});
return host;
}
}
[Collection("DiagnosticSource") /* All DiagnosticSource tests must be in the same collection to ensure they are NOT run in parallel. */]
public class HostingTest : IClassFixture, IDisposable
{
private readonly WebApplicationFactory _factory;
private readonly MockTracer _tracer;
private readonly HostingOptions _options;
public HostingTest(TestProgramFactory factory, ITestOutputHelper output)
{
_tracer = new MockTracer();
AspNetCoreDiagnosticOptions aspNetCoreOptions = new();
_options = aspNetCoreOptions.Hosting;
_factory = factory
.WithWebHostBuilder(x =>
{
x.ConfigureServices(services =>
{
services.AddLogging(logging =>
{
logging.AddXunit(output);
logging.AddFilter("OpenTracing", LogLevel.Trace);
});
services.AddOpenTracingCoreServices(builder =>
{
builder.AddAspNetCore();
builder.Services.AddSingleton(_tracer);
builder.Services.AddSingleton(Options.Create(aspNetCoreOptions));
});
});
});
}
public void Dispose()
{
_factory.Dispose();
}
private HttpClient CreateClient()
{
var client = _factory.CreateClient();
return client;
}
[Fact]
public async Task Request_creates_span()
{
var client = CreateClient();
await client.GetAsync("/foo");
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
}
[Fact]
public async Task Span_has_correct_properties()
{
var client = CreateClient();
await client.GetAsync("/foo");
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Empty(span.GeneratedErrors);
Assert.Single(span.LogEntries);
Assert.Equal("Microsoft.AspNetCore.Routing.EndpointMatched", span.LogEntries[0].Fields["event"]);
Assert.Equal("HTTP GET", span.OperationName);
Assert.Null(span.ParentId);
Assert.Empty(span.References);
Assert.Equal(5, span.Tags.Count);
Assert.Equal(Tags.SpanKindServer, span.Tags[Tags.SpanKind.Key]);
Assert.Equal("HttpIn", span.Tags[Tags.Component.Key]);
Assert.Equal("GET", span.Tags[Tags.HttpMethod.Key]);
Assert.Equal("http://localhost/foo", span.Tags[Tags.HttpUrl.Key]);
Assert.Equal(200, span.Tags[Tags.HttpStatus.Key]);
}
[Fact]
public async Task Span_has_status_404()
{
var client = CreateClient();
await client.GetAsync("/not-found");
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Equal(404, span.Tags[Tags.HttpStatus.Key]);
}
[Fact]
public async Task Extracts_trace_headers()
{
var client = CreateClient();
await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/foo")
{
Headers =
{
{ "traceid", "100" },
{ "spanid", "101" },
}
});
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Equal("100", span.Context.TraceId);
Assert.Single(span.References);
var reference = span.References[0];
Assert.Equal(References.ChildOf, reference.ReferenceType);
Assert.Equal("100", reference.Context.TraceId);
Assert.Equal("101", reference.Context.SpanId);
}
[Fact]
public async Task Does_not_Extract_trace_headers_if_disabled_in_options()
{
var client = CreateClient();
await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/foo")
{
Headers =
{
{ "ignore", "1" },
}
});
_options.ExtractEnabled = context => !context.Request.Headers.ContainsKey("ignore");
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Empty(span.References);
}
[Fact]
public async Task Ignores_requests_with_custom_rule()
{
_options.IgnorePatterns.Add(context => context.Request.Headers.ContainsKey("ignore"));
var client = CreateClient();
await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/foo")
{
Headers =
{
{ "ignore", "1" },
}
});
Assert.Empty(_tracer.FinishedSpans());
}
[Fact]
public async Task Calls_Options_OperationNameResolver()
{
_options.OperationNameResolver = _ => "test";
var client = CreateClient();
await client.GetAsync("/foo");
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Equal("test", span.OperationName);
}
[Fact]
public async Task Calls_Options_OnRequest()
{
bool onRequestCalled = false;
_options.OnRequest = (_, __) => onRequestCalled = true;
var client = CreateClient();
await client.GetAsync("/foo");
Assert.True(onRequestCalled);
}
[Fact]
public async Task Calls_Options_OnError()
{
bool onErrorCalled = false;
_options.OnError = (_, __, ___) => onErrorCalled = true;
var client = CreateClient();
try
{
await client.GetAsync("/exception");
}
catch (InvalidOperationException)
{
// The OnError handler is invoked after the request has been finished,
// so we need to wait a little bit to make sure this test isn't failing sometimes.
await Task.Delay(TimeSpan.FromMilliseconds(100));
}
Assert.True(onErrorCalled);
}
[Fact]
public async Task Creates_error_span_if_request_throws_exception()
{
var client = CreateClient();
try
{
await client.GetAsync("/exception");
}
catch (InvalidOperationException)
{
}
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.True(span.Tags[Tags.Error.Key] as bool?);
var logs = span.LogEntries;
var error = logs.FirstOrDefault(x => x.Fields.TryGetValue(LogFields.Event, out object val) && val is string and "error");
Assert.NotNull(error);
Assert.Equal("InvalidOperationException", error.Fields[LogFields.ErrorKind]);
}
}
}
================================================
FILE: test/OpenTracing.Contrib.NetCore.Tests/CoreFx/HttpHandlerDiagnosticTest.cs
================================================
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Configuration;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Mock;
using OpenTracing.Tag;
using Xunit;
using Xunit.Abstractions;
namespace OpenTracing.Contrib.NetCore.Tests.CoreFx
{
[Collection("DiagnosticSource") /* All DiagnosticSource tests must be in the same collection to ensure they are NOT run in parallel. */]
public class HttpHandlerDiagnosticTest : IDisposable
{
private readonly MockTracer _tracer;
private readonly HttpHandlerDiagnosticOptions _options;
private readonly DiagnosticManager _diagnosticsManager;
private readonly MockHttpMessageHandler _httpHandler;
private readonly HttpClient _httpClient;
private class MockHttpMessageHandler : HttpMessageHandler
{
public Func OnSend = request =>
{
return new HttpResponseMessage(HttpStatusCode.OK)
{
RequestMessage = request,
Content = new StringContent("Response")
};
};
protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// HACK: There MUST be an awaiter otherwise exceptions are not caught by the DiagnosticsHandler.
// https://github.com/dotnet/corefx/pull/27472
await Task.CompletedTask;
return OnSend(request);
}
}
public HttpHandlerDiagnosticTest(ITestOutputHelper output)
{
_tracer = new MockTracer();
_options = new HttpHandlerDiagnosticOptions();
IServiceProvider serviceProvider = new ServiceCollection()
.AddLogging(logging =>
{
logging.AddXunit(output);
})
.AddOpenTracingCoreServices(builder =>
{
builder.AddHttpHandler();
builder.Services.AddSingleton(_tracer);
builder.Services.AddSingleton(Options.Create(_options));
})
.BuildServiceProvider();
_diagnosticsManager = serviceProvider.GetRequiredService();
_diagnosticsManager.Start();
// Inner handler for mocking the result
_httpHandler = new MockHttpMessageHandler();
// Wrap with DiagnosticsHandler (which is internal :( )
#if NETCOREAPP3_1
Type type = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.DiagnosticsHandler");
ConstructorInfo constructor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
HttpMessageHandler diagnosticsHandler = (HttpMessageHandler)constructor.Invoke(new object[] { _httpHandler });
#else
DistributedContextPropagator propagator = DistributedContextPropagator.CreateDefaultPropagator();
Type type = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.DiagnosticsHandler");
ConstructorInfo constructor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
HttpMessageHandler diagnosticsHandler = (HttpMessageHandler)constructor.Invoke(new object[] { _httpHandler, propagator, false /* autoRedirect */ });
#endif
_httpClient = new HttpClient(diagnosticsHandler);
}
public void Dispose()
{
_diagnosticsManager.Dispose();
}
[Fact]
public async Task Creates_span()
{
await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values")));
Assert.Single(_tracer.FinishedSpans());
}
[Fact]
public async Task Span_is_child_of_parent()
{
// Create parent span
using (var scope = _tracer.BuildSpan("parent").StartActive())
{
await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values")));
}
var finishedSpans = _tracer.FinishedSpans();
Assert.Equal(2, finishedSpans.Count);
// Inner span is finished first
var childSpan = finishedSpans[0];
var parentSpan = finishedSpans[1];
Assert.NotSame(parentSpan, childSpan);
Assert.Single(childSpan.References);
Assert.Equal(References.ChildOf, childSpan.References[0].ReferenceType);
Assert.Same(parentSpan.Context, childSpan.References[0].Context);
}
[Fact]
public async Task Span_has_correct_properties()
{
await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values")));
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Empty(span.GeneratedErrors);
Assert.Empty(span.LogEntries);
Assert.Equal("HTTP GET", span.OperationName);
Assert.Null(span.ParentId);
Assert.Empty(span.References);
Assert.Equal(7, span.Tags.Count);
Assert.Equal(Tags.SpanKindClient, span.Tags[Tags.SpanKind.Key]);
Assert.Equal("HttpOut", span.Tags[Tags.Component.Key]);
Assert.Equal("GET", span.Tags[Tags.HttpMethod.Key]);
Assert.Equal("http://www.example.com/api/values", span.Tags[Tags.HttpUrl.Key]);
Assert.Equal("www.example.com", span.Tags[Tags.PeerHostname.Key]);
Assert.Equal(80, span.Tags[Tags.PeerPort.Key]);
Assert.Equal(200, span.Tags[Tags.HttpStatus.Key]);
}
[Fact]
public async Task Injects_trace_headers()
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
await _httpClient.SendAsync(request);
Assert.True(request.Headers.Contains("traceid"));
}
[Fact]
public async Task Does_not_inject_trace_headers_if_disabled_in_options()
{
#if NETCOREAPP3_1
_options.InjectEnabled = req => !req.Properties.ContainsKey("ignore");
#else
_options.InjectEnabled = req => !((IDictionary)req.Options).ContainsKey("ignore");
#endif
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
SetRequestOption(request, "ignore", true);
await _httpClient.SendAsync(request);
Assert.False(request.Headers.Contains("traceid"));
}
[Fact]
public async Task Ignores_requests_with_Ignore_property()
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
SetRequestOption(request, HttpHandlerDiagnosticOptions.PropertyIgnore, true);
await _httpClient.SendAsync(request);
Assert.Empty(_tracer.FinishedSpans());
}
[Fact]
public async Task Ignores_requests_with_custom_rule()
{
#if NETCOREAPP3_1
_options.IgnorePatterns.Add(req => req.Properties.ContainsKey("foo"));
#else
_options.IgnorePatterns.Add(req => ((IDictionary) req.Options).ContainsKey("foo"));
#endif
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
SetRequestOption(request, "foo", 1);
await _httpClient.SendAsync(request);
Assert.Empty(_tracer.FinishedSpans());
}
[Fact]
public async Task Calls_Options_OperationNameResolver()
{
_options.OperationNameResolver = _ => "foo";
await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values")));
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.Equal("foo", span.OperationName);
}
[Fact]
public async Task Calls_Options_OnRequest()
{
bool onRequestCalled = false;
_options.OnRequest = (_, __) => onRequestCalled = true;
await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values")));
Assert.True(onRequestCalled);
}
[Fact]
public async Task Calls_Options_OnError()
{
bool onErrorCalled = false;
_options.OnError = (_, __, ___) => onErrorCalled = true;
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
_httpHandler.OnSend = _ => throw new InvalidOperationException();
await Assert.ThrowsAsync(() => _httpClient.SendAsync(request));
Assert.True(onErrorCalled);
}
[Fact]
public async Task Creates_error_span_if_request_times_out()
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
_httpHandler.OnSend = _ => throw new TaskCanceledException();
await Assert.ThrowsAsync(() => _httpClient.SendAsync(request));
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.True(span.Tags[Tags.Error.Key] as bool?);
}
[Fact]
public async Task Creates_error_span_if_request_fails()
{
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.example.com/api/values"));
_httpHandler.OnSend = _ => throw new InvalidOperationException();
await Assert.ThrowsAsync(() => _httpClient.SendAsync(request));
var finishedSpans = _tracer.FinishedSpans();
Assert.Single(finishedSpans);
var span = finishedSpans[0];
Assert.True(span.Tags[Tags.Error.Key] as bool?);
}
private void SetRequestOption(HttpRequestMessage request, string key, TValue value)
{
#if NETCOREAPP3_1
request.Properties[key] = value;
#else
request.Options.Set(new HttpRequestOptionsKey(key), value);
#endif
}
}
}
================================================
FILE: test/OpenTracing.Contrib.NetCore.Tests/Internal/DiagnosticManagerTest.cs
================================================
using System.Collections.Generic;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using OpenTracing.Contrib.NetCore.Internal;
using OpenTracing.Mock;
using OpenTracing.Noop;
using OpenTracing.Util;
using Xunit;
namespace OpenTracing.Contrib.NetCore.Tests.Internal
{
public class DiagnosticManagerTest
{
[Fact]
public void Does_not_Start_if_Tracer_is_NoopTracer()
{
var loggerFactory = new NullLoggerFactory();
var tracer = NoopTracerFactory.Create();
var diagnosticSubscribers = new List();
var options = Options.Create(new DiagnosticManagerOptions());
using (DiagnosticManager diagnosticManager = new DiagnosticManager(loggerFactory, tracer, diagnosticSubscribers, options))
{
Assert.False(diagnosticManager.IsRunning);
diagnosticManager.Start();
Assert.False(diagnosticManager.IsRunning);
}
}
[Fact]
public void Does_not_Start_if_Tracer_is_GlobalTracer_with_NoopTracer()
{
var loggerFactory = new NullLoggerFactory();
var tracer = GlobalTracer.Instance;
var diagnosticSubscribers = new List();
var options = Options.Create(new DiagnosticManagerOptions());
using (DiagnosticManager diagnosticManager = new DiagnosticManager(loggerFactory, tracer, diagnosticSubscribers, options))
{
Assert.False(diagnosticManager.IsRunning);
diagnosticManager.Start();
Assert.False(diagnosticManager.IsRunning);
}
}
[Fact]
public void Start_if_valid_Tracer()
{
var loggerFactory = new NullLoggerFactory();
var tracer = new MockTracer();
var diagnosticSubscribers = new List();
var options = Options.Create(new DiagnosticManagerOptions());
using (DiagnosticManager diagnosticManager = new DiagnosticManager(loggerFactory, tracer, diagnosticSubscribers, options))
{
Assert.False(diagnosticManager.IsRunning);
diagnosticManager.Start();
Assert.True(diagnosticManager.IsRunning);
}
}
}
}
================================================
FILE: test/OpenTracing.Contrib.NetCore.Tests/Internal/PropertyFetcherTest.cs
================================================
using OpenTracing.Contrib.NetCore.Internal;
using Xunit;
namespace OpenTracing.Contrib.NetCore.Tests.Internal
{
public class PropertyFetcherTest
{
public class TestClass
{
public string TestProperty { get; set; }
}
[Fact]
public void Fetch_NameNotFound_NullReturned()
{
var obj = new TestClass { TestProperty = "TestValue" };
var sut = new PropertyFetcher("DifferentProperty");
var result = sut.Fetch(obj);
Assert.Null(result);
}
[Fact]
public void Fetch_NameFound_ValueReturned()
{
var obj = new TestClass { TestProperty = "TestValue" };
var sut = new PropertyFetcher("TestProperty");
var result = sut.Fetch(obj);
Assert.Equal("TestValue", result);
}
[Fact]
public void Fetch_NameFoundDifferentCasing_ValueReturned()
{
var obj = new TestClass { TestProperty = "TestValue" };
var sut = new PropertyFetcher("testproperty");
var result = sut.Fetch(obj);
Assert.Equal("TestValue", result);
}
}
}
================================================
FILE: test/OpenTracing.Contrib.NetCore.Tests/Logging/LoggingDependencyInjectionTest.cs
================================================
using System;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using OpenTracing.Propagation;
using Xunit;
namespace OpenTracing.Contrib.Netcore.Tests.Logging
{
public class LoggingDependencyInjectionTest
{
[Fact]
public void Resolving_tracer_that_needs_ILoggerFactory_succeeds()
{
// https://github.com/opentracing-contrib/csharp-netcore/issues/14
var serviceProvider = new ServiceCollection()
.AddLogging()
.AddOpenTracingCoreServices(ot =>
{
ot.AddLoggerProvider();
ot.Services.AddSingleton