public DiagnosticSourceSubscriber(Dictionary <string, Func <ITracerFactory, Func <TInput, ISampler>, ListenerHandler <TInput> > > handlers, ITracerFactory tracerFactory, Func <TInput, ISampler> sampler)
{
this.subscriptions = new ConcurrentDictionary <string, DiagnosticSourceListener <TInput> >();
this.handlers = handlers ?? throw new ArgumentNullException(nameof(handlers));
this.tracerFactory = tracerFactory ?? throw new ArgumentNullException(nameof(tracerFactory));
this.sampler = sampler ?? throw new ArgumentNullException(nameof(sampler));
}
/// <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>
/// Creates a new <see cref="TextWriterFormatWriter" /> without a <see cref="TextWriter" />. <see cref="SetTextWriter" />
/// must be called
/// before this instance can be used.
/// </summary>
/// <param name="setupTracerFactory">The <see cref="ITracerFactory" /> to use for logging setup operations.</param>
/// <param name="fieldDelimiter">The field delimiter for formatted text output.</param>
/// <param name="spacesPerIndentLevel">The number of spaces per indent level. Can be 0 for no indenting.</param>
public TextWriterFormatWriter(ITracerFactory setupTracerFactory,
string fieldDelimiter = DefaultFieldDelimiter,
int spacesPerIndentLevel = DefaultSpacesPerIndent)
: base(setupTracerFactory, fieldDelimiter, spacesPerIndentLevel)
{
_charBuffer = new char[base.FieldBuffer.Capacity];
}
/// <summary>
/// Stores <paramref name="tracerFactory" /> in the <paramref name="owinContext" />.
/// </summary>
/// <param name="owinContext">An <see cref="IOwinContext" /> for the current request.</param>
/// <param name="tracerFactory">The <see cref="ITracerFactory" /> to store.</param>
/// <returns></returns>
internal static void SetTracerFactory(this IOwinContext owinContext, ITracerFactory tracerFactory)
{
Contract.Requires <ArgumentNullException>(owinContext != null);
Contract.Requires <ArgumentNullException>(tracerFactory != null);
owinContext.Environment.Add(TracerFactoryKey, tracerFactory);
}
public SlowTestLogWriter(ITracerFactory setupTracerFactory, int msDelay, bool synchronize)
: base(setupTracerFactory, synchronize)
{
WriteEntryDelayMs = msDelay;
StartDelayMs = msDelay;
StopDelayMs = msDelay;
DisposeDelayMs = msDelay;
}
/// <summary>
/// Creates a new <see cref="ListLogWriter{TEntry}" /> using <paramref name="entryList"/>.
/// </summary>
/// <param name="setupTracerFactory"></param>
/// <param name="entryList">The <see cref="IList{T}"/> to write to.</param>
/// <param name="synchronize">
/// If set to <c>true</c> (the default), writes are synchronized, meaning entries are only added to
/// the list one thread at a time using a <c>lock</c>. If <c>false</c>, writes are not synchronized by this class, so
/// another
/// mechanism must be used to synchronize writes from multiple threads.
/// </param>
public ListLogWriter(ITracerFactory setupTracerFactory, IList <TEntry> entryList, bool synchronize = true)
: base(setupTracerFactory)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
_entryList = entryList ?? new List <TEntry>();
_isSynchronized = synchronize;
}
/// <summary>
/// Creates a new <see cref="LogManager" /> instance using the specified <paramref name="logWriters" />.
/// </summary>
/// <param name="logWriters">
/// A set of 1 or more <see cref="ILogWriter" /> instances to include in the
/// <see cref="LogManager" />.
/// </param>
public LogManager(params ILogWriter[] logWriters)
: this(logWriters.Select(logWriter => (ILogWriterConfig) new UseExistingLogWriterConfig(logWriter)).ToArray())
{
// Get the first SetupLog from the passed in logwriters
var setupTracerFactory = GetSetupTracerFactoryForComponents(logWriters.OfType <ILogJamComponent>());
_setupTracerFactory = setupTracerFactory ?? _setupTracerFactory ?? new SetupLog();
}
// REVIEW: Important that this object + ThreadProc has NO reference to the parent BackgroundMultiLogWriter.
// If there were a reference from this, it would never finalize.
public BackgroundThread(ITracerFactory setupTracerFactory, ConcurrentQueue <Action> backgroundActionQueue)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
Contract.Requires <ArgumentNullException>(backgroundActionQueue != null);
_tracer = setupTracerFactory.TracerFor(this);
_backgroundActionQueue = backgroundActionQueue;
}
public static string TryFixTracerId(this ITracerFactory tracerFactory, string tracerId)
{
if (tracerFactory.Config != null && !string.IsNullOrWhiteSpace(tracerFactory.Config.DefaultTracerId))
{
return(tracerFactory.Config.DefaultTracerId);
}
return("Default-Tracer");
}
public DebuggerFormatWriter(ITracerFactory setupTracerFactory, string fieldDelimiter = DefaultFieldDelimiter, int spacesPerIndentLevel = DefaultSpacesPerIndent)
: base(setupTracerFactory, fieldDelimiter, spacesPerIndentLevel)
{
_newLine = Console.Out.NewLine;
_lastDebuggerAttachedCheck = int.MaxValue;
_outputBuffer = new StringBuilder(4096);
_charBuffer = new char[_outputBuffer.Capacity];
}
public ValidateSyncedLogWriter(ITracerFactory setupTracerFactory, TimeSpan writeDelay)
: base(setupTracerFactory)
{
_writeDelay = writeDelay;
_startWriteCounter = 0;
_endWriteCounter = 0;
}
/// <summary>
/// Creates a new <see cref="BaseLogWriter" />.
/// </summary>
protected BaseLogWriter(ITracerFactory setupTracerFactory)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
_setupTracerFactory = setupTracerFactory;
_entryWriters = new Dictionary <Type, object>();
}
/// <summary>
/// Creates a new <see cref="ProxyLogWriter" />.
/// </summary>
/// <param name="setupTracerFactory">The <see cref="ITracerFactory" /> tracing setup operations.</param>
/// <param name="innerLogWriter">The inner <see cref="ILogWriter" /> to delegate to. Must not be <c>null</c>.</param>
protected ProxyLogWriter(ITracerFactory setupTracerFactory, ILogWriter innerLogWriter)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
Contract.Requires <ArgumentNullException>(innerLogWriter != null);
_setupTracerFactory = setupTracerFactory;
_innerLogWriter = innerLogWriter;
}
/// <summary>
/// Creates a new <see cref="TraceWriter" /> using the specified <paramref name="traceSwitch" /> and
/// <paramref name="traceEntryWriter" />.
/// </summary>
/// <param name="traceSwitch"></param>
/// <param name="traceEntryWriter"></param>
/// <param name="setupTracerFactory">
/// The <see cref="ITracerFactory" /> to use to report exceptions. If <c>null</c>,
/// logging exceptions are not reported.
/// </param>
public TraceWriter(ITraceSwitch traceSwitch, IEntryWriter <TraceEntry> traceEntryWriter, ITracerFactory setupTracerFactory)
: base(traceEntryWriter)
{
Contract.Requires <ArgumentNullException>(traceSwitch != null);
_traceSwitch = traceSwitch;
_setupTracerFactory = setupTracerFactory;
_countWritingExceptions = 0;
}
public ConsoleFormatWriter(ITracerFactory setupTracerFactory,
IConsoleColorResolver colorResolver,
string fieldDelimiter = DefaultFieldDelimiter,
int spacesPerIndentLevel = 4)
: base(setupTracerFactory, fieldDelimiter, spacesPerIndentLevel)
{
_countWriteFailures = 0;
ColorResolver = colorResolver;
}
/// <summary>
/// Creates a new <see cref="LogManager" /> instance using the specified <paramref name="logManagerConfig" /> for
/// configuration, and an optional <paramref name="setupTracerFactory" /> for logging LogJam setup and internal operations.
/// </summary>
/// <param name="logManagerConfig">
/// The <see cref="LogManagerConfig" /> that describes how this <see cref="LogManager" />
/// should be setup.
/// </param>
/// <param name="setupTracerFactory">The <see cref="ITracerFactory" /> to use for tracking internal operations.</param>
public LogManager(LogManagerConfig logManagerConfig, ITracerFactory setupTracerFactory = null)
{
Contract.Requires <ArgumentNullException>(logManagerConfig != null);
_setupTracerFactory = setupTracerFactory ?? new SetupLog();
_config = logManagerConfig;
_backgroundMultiLogWriters = new List <BackgroundMultiLogWriter>();
_logWriters = new Dictionary <ILogWriterConfig, ILogWriter>();
}
protected override FormatWriter CreateFormatWriter(ITracerFactory setupTracerFactory)
{
if (CreateTextWriter == null)
{
throw new LogJamSetupException("CreateTextWriter delegate must be set before " + GetType() + " can create a LogWriter.", this);
}
return(new TextWriterFormatWriter(setupTracerFactory, CreateTextWriter(), DisposeTextWriter, FieldDelimiter, SpacesPerIndent));
}
internal static void SafeStart(this IEnumerable collection, ITracerFactory tracerFactory)
{
Contract.Requires <ArgumentNullException>(collection != null);
Contract.Requires <ArgumentNullException>(tracerFactory != null);
foreach (object o in collection)
{
SafeStart(o as IStartable, tracerFactory);
}
}
internal BackgroundMultiLogWriter(ITracerFactory setupTracerFactory, params ILogWriter[] logWriters)
: this(setupTracerFactory)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
Contract.Requires <ArgumentNullException>(logWriters != null);
foreach (ILogWriter logWriter in logWriters)
{
CreateProxyFor(logWriter);
}
}
/// <summary>
/// Creates a new <see cref="TextWriterFormatWriter" /> with an existing <see cref="TextWriter" />.
/// </summary>
/// <param name="setupTracerFactory">The <see cref="ITracerFactory" /> to use for logging setup operations.</param>
/// <param name="textWriter">The <see cref="TextWriter" /> to write formatted log output to.</param>
/// <param name="disposeWriter">
/// Whether to dispose <paramref name="textWriter" /> when the <c>TextWriterFormatWriter</c> is
/// disposed.
/// </param>
/// <param name="fieldDelimiter">The field delimiter for formatted text output.</param>
/// <param name="spacesPerIndentLevel">The number of spaces per indent level. Can be 0 for no indenting.</param>
public TextWriterFormatWriter(ITracerFactory setupTracerFactory,
TextWriter textWriter,
bool disposeWriter = false,
string fieldDelimiter = DefaultFieldDelimiter,
int spacesPerIndentLevel = DefaultSpacesPerIndent)
: this(setupTracerFactory, fieldDelimiter, spacesPerIndentLevel)
{
Contract.Requires <ArgumentNullException>(textWriter != null);
SetTextWriter(textWriter, disposeWriter);
}
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>
/// Creates a new <see cref="TextLogWriter" />.
/// </summary>
/// <param name="setupTracerFactory">The <see cref="ITracerFactory" /> to use for logging setup operations.</param>
public TextLogWriter(ITracerFactory setupTracerFactory, FormatWriter formatWriter)
: base(setupTracerFactory)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
Contract.Requires <ArgumentNullException>(formatWriter != null);
_formatWriter = formatWriter;
// Default to true
AutoFlush = true;
}
public static ITracer GetOrCreate(this ITracerFactory tracerFactory, string tracerId)
{
var defaultTracerId = TryFixTracerId(tracerFactory, tracerId);
var theTracerId = string.IsNullOrWhiteSpace(tracerId) ? defaultTracerId : tracerId;
if (!tracerFactory.CachedTracers.ContainsKey(theTracerId))
{
tracerFactory.CachedTracers[theTracerId] = tracerFactory.CreateTracer(theTracerId);
}
return(tracerFactory.CachedTracers[theTracerId]);
}
internal BackgroundMultiLogWriter(ITracerFactory setupTracerFactory)
{
Contract.Requires <ArgumentNullException>(setupTracerFactory != null);
_setupTracerFactory = setupTracerFactory;
_tracer = setupTracerFactory.TracerFor(this);
_proxyLogWriters = new List <LogWriterProxy>();
_proxyEntryWriters = new List <object>();
_backgroundActionQueue = new ConcurrentQueue <Action>();
_backgroundThread = null;
}
internal static void SafeDispose(this IDisposable disposable, ITracerFactory tracerFactory)
{
Contract.Requires <ArgumentNullException>(tracerFactory != null);
if (disposable == null)
{
return;
}
Tracer tracer = tracerFactory.TracerFor(disposable);
disposable.SafeDispose(tracer);
}
internal static void SafeStop(this IStartable startable, ITracerFactory tracerFactory)
{
Contract.Requires <ArgumentNullException>(tracerFactory != null);
if (startable == null)
{
return;
}
Tracer tracer = tracerFactory.TracerFor(startable);
SafeStop(startable, tracer);
}
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()));
}
protected override FormatWriter CreateFormatWriter(ITracerFactory setupTracerFactory)
{
var testOutputHelper = TestOutput;
if (testOutputHelper == null)
{
throw new LogJamXUnitSetupException("TestOutputLogWriterConfig.TestOutput must be set before logging.", this);
}
return(new TestOutputFormatWriter(testOutputHelper, setupTracerFactory)
{
IncludeTimeOffset = IncludeTimeOffset
});
}
/// <summary>
/// Retrieves the <see cref="ITracerFactory" /> from the Properties collection.
/// </summary>
/// <param name="appBuilder"></param>
/// <returns></returns>
public static ITracerFactory GetTracerFactory(this IAppBuilder appBuilder)
{
Contract.Requires <ArgumentNullException>(appBuilder != null);
ITracerFactory tracerFactory = appBuilder.Properties.Get <ITracerFactory>(c_tracerFactoryKey);
if (tracerFactory == null)
{
// Includes creating the TraceManager
appBuilder.RegisterLogManager();
tracerFactory = appBuilder.Properties.Get <ITracerFactory>(c_tracerFactoryKey);
}
return(tracerFactory);
}
/// <inheritdoc />
public override ILogWriter CreateLogWriter(ITracerFactory setupTracerFactory)
{
var formatWriter = CreateFormatWriter(setupTracerFactory);
formatWriter.FieldDelimiter = FieldDelimiter;
formatWriter.SpacesPerIndent = SpacesPerIndent;
formatWriter.IncludeDate = IncludeDate;
formatWriter.IncludeTime = IncludeTime;
formatWriter.OutputTimeZone = TimeZone;
var logWriter = new TextLogWriter(setupTracerFactory, formatWriter);
ApplyConfiguredFormatters(logWriter);
return(logWriter);
}
/// <summary>
/// Initialize request and trace logging.
/// </summary>
/// <param name="logManager"></param>
/// <param name="tracerFactory"></param>
protected virtual void ConfigureLogging(IAppBuilder owinAppBuilder, out LogManager logManager, out ITracerFactory tracerFactory)
{
var logWriterConfig = new TestOutputLogWriterConfig(_testOutputHelper);
logWriterConfig.Format(new TestOutputTraceFormatter()).Format(new HttpRequestFormatter()).Format(new HttpResponseFormatter());
owinAppBuilder.GetTraceManagerConfig().TraceTo(logWriterConfig);
owinAppBuilder.GetLogManagerConfig().Writers.Add(logWriterConfig);
owinAppBuilder.TraceExceptions();
owinAppBuilder.LogHttpRequests(logWriterConfig);
tracerFactory = owinAppBuilder.GetTracerFactory();
logManager = owinAppBuilder.GetLogManager();
}
