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))); }