void GetScopeInformation(StringBuilder contentBuilder)
{
IExternalScopeProvider provider = scopeProvider;
if (provider == null)
{
return;
}
var initialLength = contentBuilder.Length;
provider.ForEachScope((scope, state) =>
{
(StringBuilder builder, int length) = state;
var first = length == builder.Length;
builder.Append(first ? "=> " : " => ").Append(scope);
}, (contentBuilder, initialLength));
bool noScopeInformation = contentBuilder.Length <= initialLength;
if (noScopeInformation)
{
return;
}
contentBuilder.Insert(initialLength, MessagePadding);
contentBuilder.AppendLine();
}
/// <summary>
/// Constructs the NLog logger.
/// </summary>
/// <param name="categoryName">The category name.</param>
/// <param name="nLogSettings">The NLog Logger Provider settings.</param>
/// <param name="externalScopeProvider">The scope data provider.</param>
public NLogLogger(string categoryName, NLogLoggerSettings nLogSettings, IExternalScopeProvider externalScopeProvider)
{
CategoryName = categoryName;
_settings = nLogSettings ?? throw new ArgumentNullException(nameof(nLogSettings));
_scopeProvider = externalScopeProvider ?? throw new ArgumentNullException(nameof(externalScopeProvider));
Logger = WrappedNLog.LogManager.GetLogger(categoryName);
}
public TestOutputHelperLogger(ITestOutputHelper testOutputHelper, IExternalScopeProvider scopeProvider, string logFormat, LogLevel minLogLevel = LogLevel.Information)
{
_testOutputHelper = testOutputHelper;
_scopeProvider = scopeProvider;
_format = logFormat ?? "[{0} {1}] - {2}";
_minLogLevel = minLogLevel;
}
/// <summary>
/// Constuctor for <see cref="LoggerBase{TEntryProcessor, TEntry}"/>
/// </summary>
/// <param name="name">Name of the logger</param>
/// <param name="entryFactory">Factory to create new entries</param>
/// <param name="entryProcessor">Processor to persist entries</param>
/// <param name="scopeProvider">Provider for scopes</param>
protected LoggerBase(string name, IEntryFactory <TEntry> entryFactory, TEntryProcessor entryProcessor, IExternalScopeProvider scopeProvider)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
_entryFactory = entryFactory ?? throw new ArgumentNullException(nameof(entryFactory));
_entryProcessor = entryProcessor ?? throw new ArgumentNullException(nameof(entryProcessor));
ScopeProvider = scopeProvider;
}
public Logger(string name, IConfiguration configuration, TelemetryClient client, IExternalScopeProvider scopeProvider)
{
this.category = name;
this.client = client;
this.scopeProvider = scopeProvider;
Dictionary <string, string> logLevels = new Dictionary <string, string>();
LogLevels = new Dictionary <string, LogLevel>();
configuration.GetSection("Logging:LogLevel").Bind(LogLevels);
foreach (KeyValuePair <string, string> kvp in logLevels)
{
if (Enum.TryParse(kvp.Value, out LogLevel logLevel))
{
LogLevels[kvp.Key] = logLevel;
}
else
{
throw new ArgumentOutOfRangeException("Logging.LogLevel", $"appsetting.*.json contains invalid [Logging:LogLevel] '${kvp.Value}'");
}
}
if (LogLevels.TryGetValue("Default", out LogLevel defaultLevel))
{
Default = defaultLevel;
}
}
/// <summary>
/// Creates the logging provider with the configuration information to connect to AWS and how the messages should be sent.
/// </summary>
/// <param name="config">Configuration on how to connect to AWS and how the log messages should be sent.</param>
/// <param name="filter">A filter function that has the logger category name and log level which can be used to filter messages being sent to AWS.</param>
/// <param name="formatter">A custom formatter which accepts a LogLevel, a state, and an exception and returns the formatted log message.</param>
public AWSLoggerProvider(AWSLoggerConfig config, Func <string, LogLevel, bool> filter, Func <LogLevel, object, Exception, string> formatter = null)
{
_scopeProvider = NullExternalScopeProvider.Instance;
_core = new AWSLoggerCore(config, "ILogger");
_customFilter = filter;
_customFormatter = formatter;
}
public FileLogger(string categoryName, string fileName, IFileLoggerProcessor processor, Func <string, LogLevel, bool> filter = null,
IExternalScopeProvider scopeProvider = null, IFileLogEntryTextBuilder textBuilder = null, Func <DateTimeOffset> timestampGetter = null)
{
if (categoryName == null)
{
throw new ArgumentNullException(nameof(categoryName));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
if (processor == null)
{
throw new ArgumentNullException(nameof(processor));
}
CategoryName = categoryName;
_processor = processor;
_state = new UpdatableState
{
FileName = fileName,
Filter = filter ?? ((c, l) => true),
ScopeProvider = scopeProvider,
TextBuilder = textBuilder ?? FileLogEntryTextBuilder.Instance,
};
_timestampGetter = timestampGetter ?? (() => DateTimeOffset.UtcNow);
}
private static object[] GetScope(IExternalScopeProvider scopeProvider)
{
var scopes = new List <object>();
scopeProvider.ForEachScope((scope, list) => list.Add(GetStateObject(scope)), scopes);
return(scopes.Count > 0 ? scopes.ToArray() : null);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventLogLogger"/> class.
/// </summary>
/// <param name="name">The name of the logger.</param>
/// <param name="settings">The <see cref="EventLogSettings"/>.</param>
/// <param name="externalScopeProvider">The <see cref="IExternalScopeProvider"/>.</param>
public EventLogLogger(string name, EventLogSettings settings, IExternalScopeProvider externalScopeProvider)
{
_name = string.IsNullOrEmpty(name) ? nameof(EventLogLogger) : name;
_settings = settings;
_externalScopeProvider = externalScopeProvider;
var logName = string.IsNullOrEmpty(settings.LogName) ? "Application" : settings.LogName;
var sourceName = string.IsNullOrEmpty(settings.SourceName) ? "Application" : settings.SourceName;
var machineName = string.IsNullOrEmpty(settings.MachineName) ? "." : settings.MachineName;
// Due to the following reasons, we cannot have these checks either here or in IsEnabled method:
// 1. Log name & source name existence check only works on local computer.
// 2. Source name existence check requires Administrative privileges.
EventLog = settings.EventLog ?? new WindowsEventLog(logName, machineName, sourceName);
// Examples:
// 1. An error occu...
// 2. ...esponse stream
_beginOrEndMessageSegmentSize = EventLog.MaxMessageSize - ContinuationString.Length;
// Example:
// ...rred while writ...
_intermediateMessageSegmentSize = EventLog.MaxMessageSize - 2 * ContinuationString.Length;
}
public void ScopesAreNotCreatedInIScopeProviderWhenScopesAreDisabled()
{
var provider = new Mock <ILoggerProvider>();
var logger = new Mock <ILogger>();
IExternalScopeProvider externalScopeProvider = null;
provider.Setup(loggerProvider => loggerProvider.CreateLogger(It.IsAny <string>()))
.Returns(logger.Object);
provider.As <ISupportExternalScope>().Setup(scope => scope.SetScopeProvider(It.IsAny <IExternalScopeProvider>()))
.Callback((IExternalScopeProvider scopeProvider) => externalScopeProvider = scopeProvider);
var factory = TestLoggerBuilder.Create(
builder => {
builder.AddProvider(provider.Object);
builder.Services.Configure <LoggerFilterOptions>(options => options.CaptureScopes = false);
});
var newLogger = factory.CreateLogger("Logger");
int scopeCount = 0;
using (newLogger.BeginScope("Scope"))
{
externalScopeProvider.ForEachScope <object>((_, __) => scopeCount++, null);
}
provider.Verify(p => p.CreateLogger("Logger"), Times.Once);
logger.Verify(l => l.BeginScope(It.IsAny <object>()), Times.Never);
Assert.Equal(0, scopeCount);
}
public virtual void BuildEntryText(StringBuilder sb, string categoryName, LogLevel logLevel, EventId eventId, string message, Exception exception,
IExternalScopeProvider scopeProvider, DateTimeOffset timestamp)
{
AppendLogLevel(sb, logLevel);
AppendCategoryName(sb, categoryName);
AppendEventId(sb, eventId);
AppendTimestamp(sb, timestamp);
if (scopeProvider != null)
{
AppendLogScopeInfo(sb, scopeProvider);
}
if (!string.IsNullOrEmpty(message))
{
AppendMessage(sb, message);
}
if (exception != null)
{
AppendException(sb, exception);
}
}
internal LogRecord(
IExternalScopeProvider scopeProvider,
DateTime timestamp,
string categoryName,
LogLevel logLevel,
EventId eventId,
string formattedMessage,
object state,
Exception exception,
IReadOnlyList <KeyValuePair <string, object> > stateValues)
{
this.scopeProvider = scopeProvider;
var activity = Activity.Current;
if (activity != null)
{
this.TraceId = activity.TraceId;
this.SpanId = activity.SpanId;
this.TraceState = activity.TraceStateString;
this.TraceFlags = activity.ActivityTraceFlags;
}
this.Timestamp = timestamp;
this.CategoryName = categoryName;
this.LogLevel = logLevel;
this.EventId = eventId;
this.FormattedMessage = formattedMessage;
this.State = state;
this.StateValues = stateValues;
this.Exception = exception;
}
internal ElmahLogger(string name, Func <string, LogLevel, bool> filter, IExternalScopeProvider scopeProvider,
IHttpContextAccessor accessor)
{
_accessor = accessor;
Name = name ?? throw new ArgumentNullException(nameof(name));
Filter = filter ?? ((category, logLevel) => true);
ScopeProvider = scopeProvider;
}
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_externalScopeProvider = scopeProvider;
foreach (var logger in _instances.Values)
{
logger.ScopeProvider = scopeProvider;
}
}
/// <summary>
/// Gets the <see cref="IExternalScopeProvider"/> for the logger
/// </summary>
/// <returns></returns>
protected virtual IExternalScopeProvider GetScopeProvider()
{
if (_options.IncludeScopes && _scopeProvider == null)
{
_scopeProvider = new LoggerExternalScopeProvider();
}
return(_options.IncludeScopes ? _scopeProvider : null);
}
/// <inheritdoc />
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
this.scopeProvider = scopeProvider;
foreach (var kvLogger in loggers)
{
kvLogger.Value.ScopeProvider = scopeProvider;
}
}
public FileLogger(string name, string pattern, Func <string, LogLevel, bool> filter, IExternalScopeProvider scopeProvider, FileLoggerProcessor loggerProcessor)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Pattern = pattern;
Filter = filter ?? ((category, logLevel) => true);
ScopeProvider = scopeProvider;
FileProcessor = loggerProcessor;
}
private IExternalScopeProvider GetScopeProvider()
{
if (_includeScopes && _scopeProvider == null)
{
_scopeProvider = new LoggerExternalScopeProvider();
}
return(_includeScopes ? _scopeProvider : null);
}
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_scopeProvider = scopeProvider;
foreach (var logger in _loggers)
{
logger.Value.ScopeProvider = scopeProvider;
}
}
/// <inheritdoc />
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_scopeProvider = scopeProvider;
if (_logger != null)
{
_logger.ScopeProvider = _scopeProvider;
}
}
private IExternalScopeProvider GetScopeProvider()
{
if (this.includeScopes && this.scopeProvider == null)
{
this.scopeProvider = new LoggerExternalScopeProvider();
}
return(this.includeScopes ? this.scopeProvider : null);
}
public RemoteLoggerProvider(IOptions <RemoteLoggerOptions> options, ILaobianLogQueue logQueue)
{
_logger = new RemoteLogger(logQueue)
{
Options = options.Value,
ScopeProvider = _externalScopeProvider
};
_externalScopeProvider = RemoteNullExternalScopeProvider.Instance;
}
public InfoFileLogger(
string categoryName,
IFileLoggerProcessor processor,
IFileLoggerSettings settings,
IExternalScopeProvider scopeProvider = null,
Func <DateTimeOffset> timestampGetter = null
) : base(categoryName, processor, settings, scopeProvider, timestampGetter)
{
}
IExternalScopeProvider GetScopeProvider()
{
if (_scopeProvider == null && Settings.IncludeScopes)
{
_scopeProvider = new LoggerExternalScopeProvider();
}
return(Settings.IncludeScopes ? _scopeProvider : null);
}
/// <inheritdoc/>
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_ScopeProvider = scopeProvider;
foreach (KeyValuePair <string, StandardOutputLogger> Logger in _Loggers)
{
Logger.Value.ScopeProvider = _ScopeProvider;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitLogger"/> class.
/// </summary>
/// <param name="name">The logger name.</param>
/// <param name="writer">The message output writer.</param>
/// <param name="scopeProvider">Provides scope for log messages.</param>
internal XunitLogger(
string name,
IXunitMessageWriter writer,
IExternalScopeProvider scopeProvider)
{
this.name = name;
this.writer = writer;
this.scopeProvider = scopeProvider;
}
protected override void AppendLogScopeInfo(StringBuilder sb, IExternalScopeProvider scopeProvider)
{
scopeProvider.ForEachScope((scope, builder) =>
{
builder.Append(' ');
AppendLogScope(builder, scope);
}, sb);
}
public FileLogger(string categoryName, FileWriter fileWriter, Func <bool> isFileLoggingEnabled, Func <bool> isPrimary, LogType logType, IExternalScopeProvider scopeProvider)
{
_fileWriter = fileWriter;
_isFileLoggingEnabled = isFileLoggingEnabled;
_isPrimary = isPrimary;
_categoryName = categoryName;
_logType = logType;
_scopeProvider = scopeProvider ?? throw new ArgumentNullException(nameof(scopeProvider));
}
/// <inheritdoc/>
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_ScopeProvider = scopeProvider;
foreach (KeyValuePair <string, DebugWindowLogger> Logger in _Loggers)
{
Logger.Value.ScopeProvider = _ScopeProvider;
}
}
/// <inheritdoc />
public void SetScopeProvider(IExternalScopeProvider scopeProvider)
{
_scopeProvider = scopeProvider;
foreach (System.Collections.Generic.KeyValuePair <string, ConsoleLogger> logger in _loggers)
{
logger.Value.ScopeProvider = _scopeProvider;
}
}