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