public DependenciesCollector(HttpClientCollectorOptions options, ITracerFactory tracerFactory)
{
var assemblyVersion = typeof(DependenciesCollector).Assembly.GetName().Version;
var httpClientListener = new HttpClientCollector(options, tracerFactory.GetTracer(nameof(HttpClientCollector), "semver:" + assemblyVersion));
var azureClientsListener = new AzureClientsCollector(tracerFactory.GetTracer(nameof(AzureClientsCollector), "semver:" + assemblyVersion));
var azurePipelineListener = new AzurePipelineCollector(tracerFactory.GetTracer(nameof(AzurePipelineCollector), "semver:" + assemblyVersion));
this.collectors.Add(httpClientListener);
this.collectors.Add(azureClientsListener);
this.collectors.Add(azurePipelineListener);
}
/// <summary>
/// Initializes a new instance of the <see cref="RequestsCollector"/> class.
/// </summary>
/// <param name="options">Configuration options for dependencies collector.</param>
/// <param name="tracerFactory">TracerFactory which creates the Tracer to record traced with.</param>
/// <param name="sampler">Sampler to use to sample dependency calls.</param>
public RequestsCollector(RequestsCollectorOptions options, ITracerFactory tracerFactory, ISampler sampler)
{
const string name = "Microsoft.AspNetCore";
this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber <HttpRequest>(
new Dictionary <string, Func <ITracerFactory, Func <HttpRequest, ISampler>, ListenerHandler <HttpRequest> > >()
{
{
name, (t, s) =>
{
var version = typeof(RequestDelegate).Assembly.GetName().Version;
var tracer = tracerFactory.GetTracer(typeof(RequestsCollector).Namespace, "semver:" + version.ToString());
return(new HttpInListener(name, tracer, s));
}
},
},
tracerFactory,
x =>
{
ISampler s = null;
try
{
s = options.CustomSampler(x);
}
catch (Exception e)
{
s = null;
CollectorEventSource.Log.ExceptionInCustomSampler(e);
}
return(s ?? sampler);
});
this.diagnosticSourceSubscriber.Subscribe();
}
/// <summary>
/// Initializes a new instance of the <see cref="DependenciesCollector"/> class.
/// </summary>
/// <param name="options">Configuration options for dependencies collector.</param>
/// <param name="tracerFactory">TracerFactory to create a Tracer to record traced with.</param>
/// <param name="sampler">Sampler to use to sample dependency calls.</param>
public DependenciesCollector(DependenciesCollectorOptions options, ITracerFactory tracerFactory, ISampler sampler)
{
this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber <HttpRequestMessage>(
new Dictionary <string, Func <ITracerFactory, Func <HttpRequestMessage, ISampler>, ListenerHandler <HttpRequestMessage> > >()
{
{
"HttpHandlerDiagnosticListener", (tf, s) =>
{
var tracer = tracerFactory.GetTracer("OpenTelemetry.Collector.Dependencies.HttpHandlerDiagnosticListener");
return(new HttpHandlerDiagnosticListener(tracer, s));
}
},
{
"Azure.Clients", (tf, s) =>
{
var tracer = tracerFactory.GetTracer("OpenTelemetry.Collector.Dependencies.Azure.Clients");
return(new AzureSdkDiagnosticListener("Azure.Clients", tracer, sampler));
}
},
{
"Azure.Pipeline", (tf, s) =>
{
var tracer = tracerFactory.GetTracer("OpenTelemetry.Collector.Dependencies.Azure.Pipeline");
return(new AzureSdkDiagnosticListener("Azure.Pipeline", tracer, sampler));
}
},
},
tracerFactory,
x =>
{
ISampler s = null;
try
{
s = options.CustomSampler(x);
}
catch (Exception e)
{
s = null;
CollectorEventSource.Log.ExceptionInCustomSampler(e);
}
return(s ?? sampler);
});
this.diagnosticSourceSubscriber.Subscribe();
}
/// <summary>
/// Trace the specified values in a new <see cref="System.Web.Http.Tracing.TraceRecord" /> if and only if tracing is
/// permitted at the given category and level.
/// </summary>
/// <param name="request">
/// The current <see cref="System.Net.Http.HttpRequestMessage" />. It may be null but doing so will prevent subsequent
/// trace analysis
/// from correlating the trace to a particular request.
/// </param>
/// <param name="category">The logical category for the trace. Users can define their own.</param>
/// <param name="level">The <see cref="System.Web.Http.Tracing.TraceLevel" /> at which to write this trace.</param>
/// <param name="traceAction">
/// The action to invoke if tracing is enabled. The caller is expected to fill in the fields of the
/// given <see cref="System.Web.Http.Tracing.TraceRecord" /> in this action.
/// </param>
public void Trace(HttpRequestMessage request, string category, System.Web.Http.Tracing.TraceLevel level, Action <System.Web.Http.Tracing.TraceRecord> traceAction)
{
Tracer tracer = _tracerFactory.GetTracer(category);
TraceLevel traceLevel = ConvertToLogJamTraceLevel(level);
if (tracer.IsTraceEnabled(traceLevel))
{
var sb = new StringBuilder();
if (request != null)
{
long requestNum = request.GetRequestNumber();
if (requestNum > 0)
{
sb.Append(requestNum);
}
else
{
sb.Append(request.RequestUri.OriginalString);
}
sb.Append(": ");
}
var traceRecord = new System.Web.Http.Tracing.TraceRecord(request, category, level);
traceAction(traceRecord);
sb.AppendFormat("{0} {1} {2} {3}", traceRecord.Kind, traceRecord.Operation, traceRecord.Operator, traceRecord.Message);
// Avoid logging the same exception over and over
Exception traceException = traceRecord.Exception;
if (traceException != null)
{
if (request != null)
{
if (request.HasRequestExceptionBeenLogged(traceException))
{
sb.AppendLine();
sb.Append(" (exception already logged)");
tracer.Trace(traceLevel, sb.ToString());
}
else
{
request.LoggedRequestException(traceException);
tracer.Trace(traceLevel, traceException, sb.ToString());
}
}
}
else
{
tracer.Trace(traceLevel, sb.ToString());
}
}
}
public static Tracer GetTracer(this ITracerFactory tracerFactory, Type type)
{
Contract.Requires <ArgumentNullException>(tracerFactory != null);
Contract.Requires <ArgumentNullException>(type != null);
// ? Convert generic types to their generic type definition - so the same
// Tracer is used for ArrayList<T> regardless of the type parameter T.
//if (type.IsGenericType)
//{
// type = type.GetGenericTypeDefinition();
//}
return(tracerFactory.GetTracer(type.GetCSharpName()));
}
public static Tracer TracerFor(this ITracerFactory tracerFactory, object traceSource)
{
Contract.Requires <ArgumentNullException>(tracerFactory != null);
Contract.Requires <ArgumentNullException>(traceSource != null);
// Handle the case where Type is passed in, when an object was expected
Type traceSourceType = traceSource as Type;
if (traceSourceType != null)
{
return(GetTracer(tracerFactory, traceSourceType));
}
return(tracerFactory.GetTracer(traceSource.GetType()));
}
public ILogger Create(string name)
{
return(new OwinLogger(_tracerFactory.GetTracer(name)));
}
public static Tracer TracerFor <T>(this ITracerFactory tracerFactory)
{
Contract.Requires <ArgumentNullException>(tracerFactory != null);
return(tracerFactory.GetTracer(typeof(T)));
}
