internal static string TraceConfigurationToString(ITraceConfiguration config)
{
var sb = new StringBuilder();
sb.Append(" Tracing: ").AppendLine();
sb.Append(" Default Trace Level: ").Append(config.DefaultTraceLevel).AppendLine();
if (config.TraceLevelOverrides.Count > 0)
{
sb.Append(" TraceLevelOverrides:").AppendLine();
foreach (var over in config.TraceLevelOverrides)
{
sb.Append(" ").Append(over.Item1).Append(" ==> ").Append(over.Item2.ToString()).AppendLine();
}
}
else
{
sb.Append(" TraceLevelOverrides: None").AppendLine();
}
sb.Append(" Trace to Console: ").Append(config.TraceToConsole).AppendLine();
sb.Append(" Trace File Name: ").Append(string.IsNullOrWhiteSpace(config.TraceFileName) ? "" : Path.GetFullPath(config.TraceFileName)).AppendLine();
sb.Append(" LargeMessageWarningThreshold: ").Append(config.LargeMessageWarningThreshold).AppendLine();
sb.Append(" PropagateActivityId: ").Append(config.PropagateActivityId).AppendLine();
sb.Append(" BulkMessageLimit: ").Append(config.BulkMessageLimit).AppendLine();
return(sb.ToString());
}
internal static string TraceConfigurationToString(ITraceConfiguration config)
{
var sb = new StringBuilder();
sb.Append(" Tracing: ").AppendLine();
sb.Append(" Trace File Name: ").Append(string.IsNullOrWhiteSpace(config.TraceFileName) ? "" : Path.GetFullPath(config.TraceFileName)).AppendLine();
return(sb.ToString());
}
static Trace()
{
configuration = new TraceConfiguration();
spanPool = new UnlimitedLazyPool <Span>(
() => new Span
{
Annotations = new Dictionary <string, string>()
});
}
public static void Initialize(ITraceConfiguration config, bool configChange = false)
{
if (config == null)
{
throw new ArgumentNullException("config", "No logger config data provided.");
}
lock (lockable)
{
if (IsInitialized && !configChange)
{
return; // Already initialized
}
loggerStoreInternCache = new Interner <string, LoggerImpl>(LOGGER_INTERN_CACHE_INITIAL_SIZE, loggerInternCacheCleanupInterval);
BulkMessageLimit = config.BulkMessageLimit;
runtimeTraceLevel = config.DefaultTraceLevel;
appTraceLevel = config.DefaultTraceLevel;
SetTraceLevelOverrides(config.TraceLevelOverrides);
RequestContext.PropagateActivityId = config.PropagateActivityId;
defaultModificationCounter++;
if (configChange)
{
return; // code below should only apply during creation
}
/*
* Encountered a null reference exception during load testing using the test adapter
* The issue appears to be related to the closing of the trace listeners, commenting out the following lines appears to "fix" the issue
* R.E. 10/12/2010
*
* foreach (TraceListener l in Trace.Listeners)
* {
* l.Close();
* }
* Trace.Listeners.Clear();
*
* // We need the default listener so that Debug.Assert and Debug.Fail work properly
* Trace.Listeners.Add(new DefaultTraceListener());
*/
InitializeLegacyTraceTelemetryConsumersConfiguration(config, LogConsumers.OfType <TelemetryManager>().FirstOrDefault() ?? new TelemetryManager());
IsInitialized = true;
}
}
/// <summary>
/// Forward traces to the telemetry abstractions based on the legacy configuration.
/// This functionality will be opt-in in the future, as we will not connect our tracing to the telemetry producer by default.
/// </summary>
/// <param name="traceConfiguration">The legacy trace configuration.</param>
/// <param name="telemetryManager">The <see cref="TelemetryManager" /> to use.</param>
private static void InitializeLegacyTraceTelemetryConsumersConfiguration(ITraceConfiguration traceConfiguration, TelemetryManager telemetryManager)
{
if (traceConfiguration == null)
{
return;
}
var newConsumers = new List <ITelemetryConsumer>();
if (traceConfiguration.TraceToConsole && !telemetryManager.TelemetryConsumers.OfType <ConsoleTelemetryConsumer>().Any())
{
newConsumers.Add(new ConsoleTelemetryConsumer());
}
if (!string.IsNullOrEmpty(traceConfiguration.TraceFileName))
{
try
{
if (!telemetryManager.TelemetryConsumers.OfType <FileTelemetryConsumer>().Any())
{
newConsumers.Add(new FileTelemetryConsumer(traceConfiguration.TraceFileName));
}
}
catch (Exception exc)
{
Trace.Listeners.Add(new DefaultTraceListener());
Trace.TraceError("Error opening trace file {0} -- Using DefaultTraceListener instead -- Exception={1}", traceConfiguration.TraceFileName, exc);
}
}
if (Trace.Listeners.Count > 0)
{
if (!telemetryManager.TelemetryConsumers.OfType <TraceTelemetryConsumer>().Any())
{
newConsumers.Add(new TraceTelemetryConsumer());
}
}
if (newConsumers.Count > 0)
{
telemetryManager.AddConsumers(newConsumers);
LogConsumers.Add(new TelemetryLogConsumer(telemetryManager));
}
}
public SpanBuilder(
ITraceReporter traceReporter,
PoolHandle <Span> spanHandle,
TraceContextScope contextScope,
ITraceConfiguration configuration)
{
this.traceReporter = traceReporter;
this.spanHandle = spanHandle;
this.contextScope = contextScope;
this.configuration = configuration;
stopwatch = Stopwatch.StartNew();
parentSpan = Context.Properties.Get <Span>(spanContextKey);
spanContextScope = Context.Properties.Use(spanContextKey, Span);
InitializeSpan();
EnrichSpanWithInheritedFields();
EnrichSpanWithContext();
}
internal static void SetTraceFileName(ITraceConfiguration config, string nodeName, DateTime timestamp)
{
const string dateFormat = "yyyy-MM-dd-HH.mm.ss.fffZ";
if (config == null)
{
throw new ArgumentNullException("config");
}
if (config.TraceFilePattern == null ||
string.IsNullOrWhiteSpace(config.TraceFilePattern) ||
config.TraceFilePattern.Equals("false", StringComparison.OrdinalIgnoreCase) ||
config.TraceFilePattern.Equals("none", StringComparison.OrdinalIgnoreCase))
{
config.TraceFileName = null;
}
else if (string.Empty.Equals(config.TraceFileName))
{
config.TraceFileName = null; // normalize
}
else
{
string traceFileDir = null;
string traceFileName = Path.GetFileName(config.TraceFilePattern);
string[] dirLocations = { Path.GetDirectoryName(config.TraceFilePattern), "appdir", "." };
foreach (var d in dirLocations)
{
if (!Directory.Exists(d))
{
continue;
}
traceFileDir = d;
break;
}
if (traceFileDir != null && !Directory.Exists(traceFileDir))
{
config.TraceFilePattern = Path.Combine(traceFileDir, traceFileName);
}
config.TraceFileName = String.Format(config.TraceFilePattern, nodeName, timestamp.ToUniversalTime().ToString(dateFormat), Dns.GetHostName());
}
}
public static Serilog.ILogger CreateLogger(ITraceConfiguration settings, string fileName = null, string tableName = null, ICollection <DataColumn> additionalColumns = null, bool?logToFile = null, bool?logToSql = null)
{
var logsPath = string.IsNullOrEmpty(Environment.GetEnvironmentVariable("WEBSITE_SITE_NAME"))
? Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)
: Path.Combine(Environment.GetEnvironmentVariable("HOME"), "LogFiles");
var logger = new LoggerConfiguration()
.Enrich.With <HttpRequestIdEnricher>()
.Enrich.With <UserNameEnricher>()
.Enrich.With <EventIdEnricher>();
if (logToFile ?? settings.LogToFile && !string.IsNullOrEmpty(fileName))
{
logger = logger.WriteTo.RollingFile(Path.Combine(logsPath, fileName), fileSizeLimitBytes: null);
}
if (logToSql ?? Convert.ToBoolean(settings.LogToSql) &&
!string.IsNullOrEmpty(settings.LoggingSqlServerConnectionString) &&
!string.IsNullOrEmpty(tableName))
{
var columnOptions = new ColumnOptions
{
AdditionalDataColumns = new Collection <DataColumn>
{
new DataColumn {
DataType = typeof(string), ColumnName = "UserName"
},
new DataColumn {
DataType = typeof(string), ColumnName = "HttpRequestId"
},
new DataColumn {
DataType = typeof(int), ColumnName = "EventId"
}
}
.Union(additionalColumns ?? Enumerable.Empty <DataColumn>())
.ToList()
};
logger = logger.WriteTo
.MSSqlServer(settings.LoggingSqlServerConnectionString, tableName, columnOptions: columnOptions);
}
return(logger.CreateLogger());
}
internal static void ParseTracing(ITraceConfiguration config, XmlElement root, string nodeName)
{
if (root.HasAttribute("DefaultTraceLevel"))
{
config.DefaultTraceLevel = ParseSeverity(root.GetAttribute("DefaultTraceLevel"),
"Invalid trace level DefaultTraceLevel attribute value on Tracing element for " + nodeName);
}
if (root.HasAttribute("TraceToConsole"))
{
config.TraceToConsole = ParseBool(root.GetAttribute("TraceToConsole"),
"Invalid boolean value for TraceToConsole attribute on Tracing element for " + nodeName);
}
if (root.HasAttribute("TraceToFile"))
{
config.TraceFilePattern = root.GetAttribute("TraceToFile");
}
if (root.HasAttribute("LargeMessageWarningThreshold"))
{
config.LargeMessageWarningThreshold = ParseInt(root.GetAttribute("LargeMessageWarningThreshold"),
"Invalid boolean value for LargeMessageWarningThresholdattribute on Tracing element for " + nodeName);
}
if (root.HasAttribute("PropagateActivityId"))
{
config.PropagateActivityId = ParseBool(root.GetAttribute("PropagateActivityId"),
"Invalid boolean value for PropagateActivityId attribute on Tracing element for " + nodeName);
}
if (root.HasAttribute("BulkMessageLimit"))
{
config.BulkMessageLimit = ParseInt(root.GetAttribute("BulkMessageLimit"),
"Invalid int value for BulkMessageLimit attribute on Tracing element for " + nodeName);
}
foreach (XmlNode node in root.ChildNodes)
{
var grandchild = node as XmlElement;
if (grandchild == null)
{
continue;
}
if (grandchild.LocalName.Equals("TraceLevelOverride") && grandchild.HasAttribute("TraceLevel") && grandchild.HasAttribute("LogPrefix"))
{
config.TraceLevelOverrides.Add(new Tuple <string, Severity>(grandchild.GetAttribute("LogPrefix"),
ParseSeverity(grandchild.GetAttribute("TraceLevel"),
"Invalid trace level TraceLevel attribute value on TraceLevelOverride element for " + nodeName + " prefix " +
grandchild.GetAttribute("LogPrefix"))));
}
else if (grandchild.LocalName.Equals("LogConsumer"))
{
var className = grandchild.InnerText;
Assembly assembly = null;
try
{
int pos = className.IndexOf(',');
if (pos > 0)
{
var assemblyName = className.Substring(pos + 1).Trim();
className = className.Substring(0, pos).Trim();
assembly = Assembly.Load(new AssemblyName(assemblyName));
}
else
{
assembly = typeof(ConfigUtilities).GetTypeInfo().Assembly;
}
var pluginType = assembly.GetType(className);
if (pluginType == null)
{
throw new TypeLoadException("Cannot locate plugin class " + className + " in assembly " + assembly.FullName);
}
var plugin = Activator.CreateInstance(pluginType);
if (plugin is ILogConsumer)
{
TraceLogger.LogConsumers.Add(plugin as ILogConsumer);
}
else
{
throw new InvalidCastException("LogConsumer class " + className + " must implement Orleans.ILogConsumer interface");
}
}
catch (Exception exc)
{
throw new TypeLoadException("Cannot load LogConsumer class " + className + " from assembly " + assembly + " - Error=" + exc);
}
}
}
SetTraceFileName(config, nodeName, DateTime.UtcNow);
}
public static void Initialize(ITraceConfiguration config, bool configChange = false)
{
lock (lockable)
{
if (IsInitialized && !configChange)
{
return; // Already initialized
}
loggerStoreInternCache = new Interner <string, TraceLogger>(LOGGER_INTERN_CACHE_INITIAL_SIZE, loggerInternCacheCleanupInterval);
BulkMessageLimit = config.BulkMessageLimit;
runtimeTraceLevel = config.DefaultTraceLevel;
appTraceLevel = config.DefaultTraceLevel;
SetTraceLevelOverrides(config.TraceLevelOverrides);
Message.WriteMessagingTraces = config.WriteMessagingTraces;
Message.LargeMessageSizeThreshold = config.LargeMessageWarningThreshold;
SerializationManager.LARGE_OBJECT_LIMIT = config.LargeMessageWarningThreshold;
RequestContext.PropagateActivityId = config.PropagateActivityId;
defaultModificationCounter++;
if (configChange)
{
return; // code below should only apply during creation
}
/*
* Encountered a null reference exception during load testing using the test adapter
* The issue appears to be related to the closing of the trace listeners, commenting out the following lines appears to "fix" the issue
* R.E. 10/12/2010
*
* foreach (TraceListener l in Trace.Listeners)
* {
* l.Close();
* }
* Trace.Listeners.Clear();
*
* // We need the default listener so that Debug.Assert and Debug.Fail work properly
* Trace.Listeners.Add(new DefaultTraceListener());
*/
if (config.TraceToConsole)
{
bool containsConsoleListener = false;
foreach (TraceListener l in Trace.Listeners)
{
if (l.GetType() != typeof(ConsoleTraceListener))
{
continue;
}
containsConsoleListener = true;
break;
}
if (!containsConsoleListener)
{
LogConsumers.Add(new LogWriterToConsole());
}
}
if (!string.IsNullOrEmpty(config.TraceFileName))
{
try
{
logOutputFile = new FileInfo(config.TraceFileName);
var l = new LogWriterToFile(logOutputFile);
LogConsumers.Add(l);
}
catch (Exception exc)
{
Trace.Listeners.Add(new DefaultTraceListener());
Trace.TraceError("Error opening trace file {0} -- Using DefaultTraceListener instead -- Exception={1}", logOutputFile, exc);
}
}
if (Trace.Listeners.Count > 0)
{
// Plumb in log consumer to write to Trace listeners
var traceLogConsumer = new LogWriterToTrace();
LogConsumers.Add(traceLogConsumer);
}
IsInitialized = true;
}
}
public static void Initialize(ITraceConfiguration config, bool configChange = false)
{
if (config == null)
{
throw new ArgumentNullException("config", "No logger config data provided.");
}
lock (lockable)
{
if (IsInitialized && !configChange)
{
return; // Already initialized
}
loggerStoreInternCache = new Interner <string, LoggerImpl>(LOGGER_INTERN_CACHE_INITIAL_SIZE, loggerInternCacheCleanupInterval);
BulkMessageLimit = config.BulkMessageLimit;
runtimeTraceLevel = config.DefaultTraceLevel;
appTraceLevel = config.DefaultTraceLevel;
SetTraceLevelOverrides(config.TraceLevelOverrides);
Message.LargeMessageSizeThreshold = config.LargeMessageWarningThreshold;
SerializationManager.LARGE_OBJECT_LIMIT = config.LargeMessageWarningThreshold;
RequestContext.PropagateActivityId = config.PropagateActivityId;
defaultModificationCounter++;
if (configChange)
{
return; // code below should only apply during creation
}
/*
* Encountered a null reference exception during load testing using the test adapter
* The issue appears to be related to the closing of the trace listeners, commenting out the following lines appears to "fix" the issue
* R.E. 10/12/2010
*
* foreach (TraceListener l in Trace.Listeners)
* {
* l.Close();
* }
* Trace.Listeners.Clear();
*
* // We need the default listener so that Debug.Assert and Debug.Fail work properly
* Trace.Listeners.Add(new DefaultTraceListener());
*/
if (config.TraceToConsole)
{
if (!TelemetryConsumers.OfType <ConsoleTelemetryConsumer>().Any())
{
TelemetryConsumers.Add(new ConsoleTelemetryConsumer());
}
}
if (!string.IsNullOrEmpty(config.TraceFileName))
{
try
{
if (!TelemetryConsumers.OfType <FileTelemetryConsumer>().Any())
{
TelemetryConsumers.Add(new FileTelemetryConsumer(config.TraceFileName));
}
}
catch (Exception exc)
{
Trace.Listeners.Add(new DefaultTraceListener());
Trace.TraceError("Error opening trace file {0} -- Using DefaultTraceListener instead -- Exception={1}", config.TraceFileName, exc);
}
}
if (Trace.Listeners.Count > 0)
{
if (!TelemetryConsumers.OfType <TraceTelemetryConsumer>().Any())
{
TelemetryConsumers.Add(new TraceTelemetryConsumer());
}
}
IsInitialized = true;
}
}
internal static void ParseTracing(ITraceConfiguration config, XmlElement root, string nodeName)
{
SetTraceFileName(config, nodeName, DateTime.UtcNow);
}
