NetEventSource.cs

Go to the documentation of this file.

using System.Collections;
using System.Diagnostics.Tracing;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
 
namespace System.Net;
 
[EventSource(Name = "Private.InternalDiagnostics.System.Net.Quic")]
internal sealed class NetEventSource : EventSource
{
    public static class Keywords
    {
        public const EventKeywords Default = (EventKeywords)1L;
 
        public const EventKeywords Debug = (EventKeywords)2L;
    }
 
    public static readonly System.Net.NetEventSource Log = new System.Net.NetEventSource();
 
    [NonEvent]
    public static void Info(object thisOrContextObject, FormattableString formattableString = null, [CallerMemberName] string memberName = null)
    {
        if (Log.IsEnabled())
        {
            Log.Info(IdOf(thisOrContextObject), memberName, (formattableString != null) ? Format(formattableString) : "");
        }
    }
 
    [NonEvent]
    public static void Info(object thisOrContextObject, object message, [CallerMemberName] string memberName = null)
    {
        if (Log.IsEnabled())
        {
            Log.Info(IdOf(thisOrContextObject), memberName, Format(message).ToString());
        }
    }
 
    [Event(4, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
    private void Info(string thisOrContextObject, string memberName, string message)
    {
        WriteEvent(4, thisOrContextObject, memberName ?? "(?)", message);
    }
 
    [NonEvent]
    public static void Error(object thisOrContextObject, FormattableString formattableString, [CallerMemberName] string memberName = null)
    {
        if (Log.IsEnabled())
        {
            Log.ErrorMessage(IdOf(thisOrContextObject), memberName, Format(formattableString));
        }
    }
 
    [Event(5, Level = EventLevel.Error, Keywords = (EventKeywords)1L)]
    private void ErrorMessage(string thisOrContextObject, string memberName, string message)
    {
        WriteEvent(5, thisOrContextObject, memberName ?? "(?)", message);
    }
 
    [NonEvent]
    public static string IdOf(object value)
    {
        if (value == null)
        {
            return "(null)";
        }
        return value.GetType().Name + "#" + GetHashCode(value);
    }
 
    [NonEvent]
    public static int GetHashCode(object value)
    {
        return value?.GetHashCode() ?? 0;
    }
 
    [NonEvent]
    public static object Format(object value)
    {
        if (value == null)
        {
            return "(null)";
        }
        string text = null;
        if (text != null)
        {
            return text;
        }
        if (value is Array array)
        {
            return $"{array.GetType().GetElementType()}[{((Array)value).Length}]";
        }
        if (value is ICollection collection)
        {
            return $"{collection.GetType().Name}({collection.Count})";
        }
        if (value is SafeHandle safeHandle)
        {
            return $"{safeHandle.GetType().Name}:{safeHandle.GetHashCode()}(0x{safeHandle.DangerousGetHandle():X})";
        }
        if (value is IntPtr)
        {
            return $"0x{value:X}";
        }
        string text2 = value.ToString();
        if (text2 == null || text2 == value.GetType().FullName)
        {
            return IdOf(value);
        }
        return value;
    }
 
    [NonEvent]
    private static string Format(FormattableString s)
    {
        switch (s.ArgumentCount)
        {
        case 0:
            return s.Format;
        case 1:
            return string.Format(s.Format, Format(s.GetArgument(0)));
        case 2:
            return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)));
        case 3:
            return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)), Format(s.GetArgument(2)));
        default:
        {
            object[] arguments = s.GetArguments();
            object[] array = new object[arguments.Length];
            for (int i = 0; i < arguments.Length; i++)
            {
                array[i] = Format(arguments[i]);
            }
            return string.Format(s.Format, array);
        }
        }
    }
}