using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using Serilog.Configuration;
using Serilog.Core;
using Serilog.Events;
using Serilog.Sinks.Map;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Serilog.Sinks.Map.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100fb8d13fd344a1c6fe0fe83ef33c1080bf30690765bc6eb0df26ebfdf8f21670c64265b30db09f73a0dea5b3db4c9d18dbf6d5a25af5ce9016f281014d79dc3b4201ac646c451830fc7e61a2dfd633d34c39f87b81894191652df5ac63cc40c77f3542f702bda692e6e8a9158353df189007a49da0f3cfd55eb250066b19485ec")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Serilog Contributors")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © Serilog Contributors")]
[assembly: AssemblyDescription("A Serilog sink wrapper that dispatches events based on a property value.")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+5cff06e49235500f641296a4a8e8a56be7788dfe")]
[assembly: AssemblyProduct("Serilog.Sinks.Map")]
[assembly: AssemblyTitle("Serilog.Sinks.Map")]
[assembly: AssemblyVersion("2.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Serilog
{
public static class MapLoggerConfigurationExtensions
{
public static LoggerConfiguration Map(this LoggerSinkConfiguration loggerSinkConfiguration, string keyPropertyName, string defaultKey, Action<string, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
string keyPropertyName2 = keyPropertyName;
string defaultKey2 = defaultKey;
return loggerSinkConfiguration.Map((Func<LogEvent, string>)delegate(LogEvent le)
{
if (le.Properties.TryGetValue(keyPropertyName2, out var value))
{
ScalarValue val = (ScalarValue)(object)((value is ScalarValue) ? value : null);
if (val != null)
{
return val.Value?.ToString() ?? defaultKey2;
}
}
return defaultKey2;
}, configure, sinkMapCountLimit, restrictedToMinimumLevel, levelSwitch);
}
public static LoggerConfiguration Map<TKey>(this LoggerSinkConfiguration loggerSinkConfiguration, string keyPropertyName, TKey defaultKey, Action<TKey, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
string keyPropertyName2 = keyPropertyName;
TKey defaultKey2 = defaultKey;
if (loggerSinkConfiguration == null)
{
throw new ArgumentNullException("loggerSinkConfiguration");
}
if (keyPropertyName2 == null)
{
throw new ArgumentNullException("keyPropertyName");
}
if (configure == null)
{
throw new ArgumentNullException("configure");
}
return loggerSinkConfiguration.Map(delegate(LogEvent le)
{
if (le.Properties.TryGetValue(keyPropertyName2, out var value))
{
ScalarValue val = (ScalarValue)(object)((value is ScalarValue) ? value : null);
if (val != null)
{
object value2 = val.Value;
if (value2 is TKey)
{
return (TKey)value2;
}
}
}
return defaultKey2;
}, configure, sinkMapCountLimit, restrictedToMinimumLevel, levelSwitch);
}
public static LoggerConfiguration Map<TKey>(this LoggerSinkConfiguration loggerSinkConfiguration, Func<LogEvent, TKey> keySelector, Action<TKey, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
Func<LogEvent, TKey> keySelector2 = keySelector;
if (loggerSinkConfiguration == null)
{
throw new ArgumentNullException("loggerSinkConfiguration");
}
if (keySelector2 == null)
{
throw new ArgumentNullException("keySelector");
}
if (configure == null)
{
throw new ArgumentNullException("configure");
}
if (sinkMapCountLimit.HasValue && sinkMapCountLimit.GetValueOrDefault() < 0)
{
throw new ArgumentOutOfRangeException("sinkMapCountLimit");
}
return loggerSinkConfiguration.Sink((ILogEventSink)(object)new MappedSink<TKey>((LogEvent logEvent, [MaybeNull] out TKey key) =>
{
key = keySelector2(logEvent);
return true;
}, configure, sinkMapCountLimit), restrictedToMinimumLevel, levelSwitch);
}
public static LoggerConfiguration Map(this LoggerSinkConfiguration loggerSinkConfiguration, string keyPropertyName, Action<string?, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
string keyPropertyName2 = keyPropertyName;
return loggerSinkConfiguration.Map(delegate(LogEvent le, out string? key)
{
if (le.Properties.TryGetValue(keyPropertyName2, out var value))
{
ScalarValue val = (ScalarValue)(object)((value is ScalarValue) ? value : null);
if (val != null)
{
key = val.Value?.ToString();
return true;
}
}
key = null;
return false;
}, configure, sinkMapCountLimit, restrictedToMinimumLevel, levelSwitch);
}
public static LoggerConfiguration Map<TKey>(this LoggerSinkConfiguration loggerSinkConfiguration, string keyPropertyName, Action<TKey, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
string keyPropertyName2 = keyPropertyName;
if (loggerSinkConfiguration == null)
{
throw new ArgumentNullException("loggerSinkConfiguration");
}
if (keyPropertyName2 == null)
{
throw new ArgumentNullException("keyPropertyName");
}
if (configure == null)
{
throw new ArgumentNullException("configure");
}
return loggerSinkConfiguration.Map<TKey>(delegate(LogEvent le, out TKey? key)
{
if (le.Properties.TryGetValue(keyPropertyName2, out var value))
{
ScalarValue val = (ScalarValue)(object)((value is ScalarValue) ? value : null);
if (val != null && val.Value is TKey val2)
{
key = val2;
return true;
}
}
key = default(TKey);
return false;
}, configure, sinkMapCountLimit, restrictedToMinimumLevel, levelSwitch);
}
public static LoggerConfiguration Map<TKey>(this LoggerSinkConfiguration loggerSinkConfiguration, KeySelector<TKey> keySelector, Action<TKey, LoggerSinkConfiguration> configure, int? sinkMapCountLimit = null, LogEventLevel restrictedToMinimumLevel = 0, LoggingLevelSwitch? levelSwitch = null)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
if (loggerSinkConfiguration == null)
{
throw new ArgumentNullException("loggerSinkConfiguration");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
if (configure == null)
{
throw new ArgumentNullException("configure");
}
if (sinkMapCountLimit.HasValue && sinkMapCountLimit.GetValueOrDefault() < 0)
{
throw new ArgumentOutOfRangeException("sinkMapCountLimit");
}
return loggerSinkConfiguration.Sink((ILogEventSink)(object)new MappedSink<TKey>(keySelector, configure, sinkMapCountLimit), restrictedToMinimumLevel, levelSwitch);
}
}
}
namespace Serilog.Sinks.Map
{
public delegate bool KeySelector<TKey>(LogEvent logEvent, [MaybeNull] out TKey key);
internal class MappedSink<TKey> : ILogEventSink, IDisposable
{
private readonly KeySelector<TKey> _keySelector;
private readonly Action<TKey, LoggerSinkConfiguration> _configure;
private readonly int? _sinkMapCountLimit;
private readonly object _sync = new object();
private readonly Dictionary<KeyValuePair<TKey, bool>, ILogEventSink> _sinkMap = new Dictionary<KeyValuePair<TKey, bool>, ILogEventSink>();
private bool _disposed;
public MappedSink(KeySelector<TKey> keySelector, Action<TKey, LoggerSinkConfiguration> configure, int? sinkMapCountLimit)
{
_keySelector = keySelector;
_configure = configure;
_sinkMapCountLimit = sinkMapCountLimit;
}
public void Emit(LogEvent logEvent)
{
if (!_keySelector(logEvent, out var key2))
{
return;
}
KeyValuePair<TKey, bool> key = new KeyValuePair<TKey, bool>(key2, value: false);
lock (_sync)
{
if (_disposed)
{
throw new ObjectDisposedException("MappedSink", "The mapped sink has been disposed.");
}
if (_sinkMap.TryGetValue(key, out ILogEventSink value))
{
value.Emit(logEvent);
return;
}
ILogEventSink val = LoggerSinkConfiguration.CreateSink((Action<LoggerSinkConfiguration>)delegate(LoggerSinkConfiguration wt)
{
_configure(key.Key, wt);
});
if (_sinkMapCountLimit == 0)
{
using (val as IDisposable)
{
val.Emit(logEvent);
return;
}
}
if (!_sinkMapCountLimit.HasValue || _sinkMapCountLimit > _sinkMap.Count)
{
_sinkMap[key] = val;
val.Emit(logEvent);
return;
}
_sinkMap[key] = val;
try
{
val.Emit(logEvent);
}
finally
{
while (_sinkMap.Count > _sinkMapCountLimit.Value)
{
foreach (KeyValuePair<TKey, bool> key3 in _sinkMap.Keys)
{
if (!key.Equals(key3))
{
ILogEventSink obj = _sinkMap[key3];
_sinkMap.Remove(key3);
(obj as IDisposable)?.Dispose();
break;
}
}
}
}
}
}
public void Dispose()
{
lock (_sync)
{
if (!_disposed)
{
_disposed = true;
ILogEventSink[] array = _sinkMap.Values.ToArray();
_sinkMap.Clear();
ILogEventSink[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
(array2[i] as IDisposable)?.Dispose();
}
}
}
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class AllowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class DisallowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class DoesNotReturnAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class DoesNotReturnIfAttribute : Attribute
{
public bool ParameterValue { get; }
public DoesNotReturnIfAttribute(bool parameterValue)
{
ParameterValue = parameterValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class MaybeNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class MaybeNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public MaybeNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class MemberNotNullAttribute : Attribute
{
public string[] Members { get; }
public MemberNotNullAttribute(string member)
{
Members = new string[1] { member };
}
public MemberNotNullAttribute(params string[] members)
{
Members = members;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class MemberNotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public string[] Members { get; }
public MemberNotNullWhenAttribute(bool returnValue, string member)
{
ReturnValue = returnValue;
Members = new string[1] { member };
}
public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
{
ReturnValue = returnValue;
Members = members;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class NotNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class NotNullIfNotNullAttribute : Attribute
{
public string ParameterName { get; }
public NotNullIfNotNullAttribute(string parameterName)
{
ParameterName = parameterName;
}
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
internal sealed class NotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public NotNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
}
