< Summary

Information

Class:	System.Net.NetEventSource
Assembly:	System.Net.Security
File(s):	File 1: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.cs File 2: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.DumpBuffer.cs File 3: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Security/NetEventSource.Security.Windows.cs File 4: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Net.Security/src/System/Net/Security/NetEventSource.Security.cs

Line coverage

Covered lines:	1
Uncovered lines:	332
Coverable lines:	333
Total lines:	833
Line coverage:	0.3%

Branch coverage

Covered branches:	0
Total branches:	105
Branch coverage:	0%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

Method	Branch coverage	Cyclomatic complexity	NPath complexity	Sequence coverage
File 1: .cctor()	100%	1	1	100%
File 1: Info(...)	0%	2	2	0%
File 1: Info(...)	100%	1	1	0%
File 1: Info(...)	0%	2	2	0%
File 1: Error(...)	100%	1	1	0%
File 1: Error(...)	100%	1	1	0%
File 1: ErrorMessage(...)	0%	2	2	0%
File 1: IdOf(...)	0%	2	2	0%
File 1: GetHashCode(...)	0%	2	2	0%
File 1: Format(...)	0%	16	16	0%
File 1: Format(...)	0%	7	7	0%
File 1: WriteEvent(...)	0%	8	8	0%
File 2: DumpBuffer(...)	100%	1	1	0%
File 2: DumpBuffer(...)	0%	2	2	0%
File 2: WriteEvent(...)	0%	14	14	0%
File 3: EnumerateSecurityPackages(...)	100%	1	1	0%
File 3: SspiPackageNotFound(...)	100%	1	1	0%
File 3: AcquireDefaultCredential(...)	100%	1	1	0%
File 3: AcquireCredentialsHandle(...)	100%	1	1	0%
File 3: AcquireCredentialsHandle(...)	100%	1	1	0%
File 3: InitializeSecurityContext(...)	100%	1	1	0%
File 3: InitializeSecurityContext(...)	100%	1	1	0%
File 3: AcceptSecurityContext(...)	100%	1	1	0%
File 3: AcceptSecurityContext(...)	100%	1	1	0%
File 3: OperationReturnedSomething(...)	100%	1	1	0%
File 3: SecurityContextInputBuffers(...)	100%	1	1	0%
File 3: WriteEvent(...)	0%	4	4	0%
File 3: WriteEvent(...)	0%	8	8	0%
File 3: WriteEvent(...)	0%	12	12	0%
File 4: SslStreamCtor(...)	0%	8	8	0%
File 4: SslStreamCtor(...)	100%	1	1	0%
File 4: LocatingPrivateKey(...)	100%	1	1	0%
File 4: LocatingPrivateKey(...)	100%	1	1	0%
File 4: CertIsType2(...)	100%	1	1	0%
File 4: CertIsType2(...)	100%	1	1	0%
File 4: FoundCertInStore(...)	0%	2	2	0%
File 4: FoundCertInStore(...)	100%	1	1	0%
File 4: NotFoundCertInStore(...)	100%	1	1	0%
File 4: NotFoundCertInStore(...)	100%	1	1	0%
File 4: RemoteCertificate(...)	0%	2	2	0%
File 4: RemoteCertificate(...)	100%	1	1	0%
File 4: CertificateFromDelegate(...)	100%	1	1	0%
File 4: CertificateFromDelegate(...)	100%	1	1	0%
File 4: NoDelegateNoClientCert(...)	100%	1	1	0%
File 4: NoDelegateNoClientCert(...)	100%	1	1	0%
File 4: NoDelegateButClientCert(...)	100%	1	1	0%
File 4: NoDelegateButClientCert(...)	100%	1	1	0%
File 4: AttemptingRestartUsingCert(...)	0%	2	2	0%
File 4: AttemptingRestartUsingCert(...)	100%	1	1	0%
File 4: NoIssuersTryAllCerts(...)	100%	1	1	0%
File 4: NoIssuersTryAllCerts(...)	100%	1	1	0%
File 4: LookForMatchingCerts(...)	100%	1	1	0%
File 4: LookForMatchingCerts(...)	100%	1	1	0%
File 4: SelectedCert(...)	0%	2	2	0%
File 4: SelectedCert(...)	100%	1	1	0%
File 4: CertsAfterFiltering(...)	100%	1	1	0%
File 4: CertsAfterFiltering(...)	100%	1	1	0%
File 4: FindingMatchingCerts(...)	100%	1	1	0%
File 4: FindingMatchingCerts(...)	100%	1	1	0%
File 4: UsingCachedCredential(...)	100%	1	1	0%
File 4: UsingCachedCredential(...)	100%	1	1	0%
File 4: SspiSelectedCipherSuite(...)	100%	1	1	0%
File 4: RemoteCertificateError(...)	100%	1	1	0%
File 4: RemoteCertificateError(...)	100%	1	1	0%
File 4: RemoteCertDeclaredValid(...)	100%	1	1	0%
File 4: RemoteCertDeclaredValid(...)	100%	1	1	0%
File 4: RemoteCertHasNoErrors(...)	100%	1	1	0%
File 4: RemoteCertHasNoErrors(...)	100%	1	1	0%
File 4: RemoteCertUserDeclaredInvalid(...)	100%	1	1	0%
File 4: RemoteCertUserDeclaredInvalid(...)	100%	1	1	0%
File 4: SentFrame(...)	0%	2	2	0%
File 4: SentFrame(...)	100%	1	1	0%
File 4: ReceivedFrame(...)	100%	1	1	0%
File 4: ReceivedFrame(...)	100%	1	1	0%
File 4: CertificateFromCertContext(...)	100%	1	1	0%
File 4: CertificateFromCertContext(...)	100%	1	1	0%
File 4: AdditionalCustomizedToString(...)	0%	2	2	0%
File 4: WriteEvent(...)	0%	4	4	0%

File(s)

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.cs

#	Line	Line coverage
	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
	`3`
	`4`	`using System.Collections;`
	`5`	`using System.Diagnostics;`
	`6`	`using System.Diagnostics.CodeAnalysis;`
	`7`	`using System.Diagnostics.Tracing;`
	`8`	`using System.Runtime.CompilerServices;`
	`9`	`using System.Runtime.InteropServices;`
	`10`
	`11`	`#pragma warning disable CA1823 // not all IDs are used by all partial providers`
	`12`
	`13`	`namespace System.Net`
	`14`	`{`
	`15`	`// Implementation:`
	`16`	`// This partial file is meant to be consumed into each System.Net.* assembly that needs to log. Each such assembly`
	`17`	`// its own NetEventSource partial class that adds an appropriate [EventSource] attribute, giving it a unique name fo`
	`18`	`// Those partials can then also add additional events if needed, starting numbering from the NextAvailableEventId de`
	`19`
	`20`	`// Usage:`
	`21`	`// - Operations that may allocate (e.g. boxing a value type, using string interpolation, etc.) or that may have comp`
	`22`	`// at call sites should guard access like:`
	`23`	`// if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, $"Found certificate: {cert}"); // info loggin`
	`24`	`// - Operations that have zero allocations / measurable computations at call sites can use a simpler pattern, callin`
	`25`	`// NetEventSource.Info(this, "literal string"); // arbitrary message with a literal string`
	`26`	`// Debug.Asserts inside the logging methods will help to flag some misuse if the DEBUG_NETEVENTSOURCE_MISUSE compi`
	`27`	`// However, because it can be difficult by observation to understand all of the costs involved, guarding can be do`
	`28`	`// - Messages can be strings, formattable strings, or any other object. Objects (including those used in formattabl`
	`29`	`// formatting applied, controlled by the Format method. Partial specializations can also override this formatting`
	`30`	`// method that takes an object and optionally provides a string representation of it, in case a particular library`
	`31`
	`32`	`/// <summary>Provides logging facilities for System.Net libraries.</summary>`
	`33`	`internal sealed partial class NetEventSource : EventSource`
	`34`	`{`
	`35`	`private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe"`
	`36`
	`37`	`/// <summary>The single event source instance to use for all logging.</summary>`
1	`38`	`public static readonly NetEventSource Log = new NetEventSource();`
	`39`
	`40`	`#region Metadata`
	`41`	`private const string MissingMember = "(?)";`
	`42`	`private const string NullInstance = "(null)";`
	`43`	`private const string StaticMethodObject = "(static)";`
	`44`	`private const string NoParameters = "";`
	`45`
	`46`	`private const int InfoEventId = 1;`
	`47`	`private const int ErrorEventId = 2;`
	`48`	`// private const int AssociateEventId = 3; // Defined in NetEventSource.Common.Associate.cs`
	`49`	`// private const int DumpArrayEventId = 4; // Defined in NetEventSource.Common.DumpBuffer.cs`
	`50`
	`51`	`private const int NextAvailableEventId = 5; // Update this value whenever new events are added. Derived types s`
	`52`	`#endregion`
	`53`
	`54`	`#region Info`
	`55`	`/// <summary>Logs an information message.</summary>`
	`56`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`57`	`/// <param name="formattableString">The message to be logged.</param>`
	`58`	`/// <param name="memberName">The calling member.</param>`
	`59`	`[NonEvent]`
	`60`	`public static void Info(object? thisOrContextObject, FormattableString? formattableString = null, [CallerMemberN`
0	`61`	`Log.Info(IdOf(thisOrContextObject), memberName, formattableString != null ? Format(formattableString) : NoPa`
	`62`
	`63`	`/// <summary>Logs an information message.</summary>`
	`64`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`65`	`/// <param name="message">The message to be logged.</param>`
	`66`	`/// <param name="memberName">The calling member.</param>`
	`67`	`[NonEvent]`
	`68`	`public static void Info(object? thisOrContextObject, object? message, [CallerMemberName] string? memberName = nu`
0	`69`	`Log.Info(IdOf(thisOrContextObject), memberName, Format(message));`
	`70`
	`71`	`[Event(InfoEventId, Level = EventLevel.Informational)]`
	`72`	`private void Info(string thisOrContextObject, string? memberName, string? message)`
0	`73`	`{`
0	`74`	`Debug.Assert(IsEnabled());`
0	`75`	`WriteEvent(InfoEventId, thisOrContextObject, memberName ?? MissingMember, message);`
0	`76`	`}`
	`77`	`#endregion`
	`78`
	`79`	`#region Error`
	`80`	`/// <summary>Logs an error message.</summary>`
	`81`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`82`	`/// <param name="formattableString">The message to be logged.</param>`
	`83`	`/// <param name="memberName">The calling member.</param>`
	`84`	`[NonEvent]`
	`85`	`public static void Error(object? thisOrContextObject, FormattableString formattableString, [CallerMemberName] st`
0	`86`	`Log.ErrorMessage(IdOf(thisOrContextObject), memberName, Format(formattableString));`
	`87`
	`88`	`/// <summary>Logs an error message.</summary>`
	`89`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`90`	`/// <param name="message">The message to be logged.</param>`
	`91`	`/// <param name="memberName">The calling member.</param>`
	`92`	`[NonEvent]`
	`93`	`public static void Error(object? thisOrContextObject, object message, [CallerMemberName] string? memberName = nu`
0	`94`	`Log.ErrorMessage(IdOf(thisOrContextObject), memberName, Format(message));`
	`95`
	`96`	`[Event(ErrorEventId, Level = EventLevel.Error)]`
	`97`	`private void ErrorMessage(string thisOrContextObject, string? memberName, string? message)`
0	`98`	`{`
0	`99`	`Debug.Assert(IsEnabled());`
0	`100`	`WriteEvent(ErrorEventId, thisOrContextObject, memberName ?? MissingMember, message);`
0	`101`	`}`
	`102`	`#endregion`
	`103`
	`104`	`#region Helpers`
	`105`	`[NonEvent]`
0	`106`	`public static string IdOf(object? value) => value != null ? value.GetType().Name + "#" + GetHashCode(value) : Nu`
	`107`
	`108`	`[NonEvent]`
0	`109`	`public static int GetHashCode(object? value) => value?.GetHashCode() ?? 0;`
	`110`
	`111`	`[NonEvent]`
	`112`	`public static string? Format(object? value)`
0	`113`	`{`
	`114`	`// If it's null, return a known string for null values`
0	`115`	`if (value == null)`
0	`116`	`{`
0	`117`	`return NullInstance;`
	`118`	`}`
	`119`
	`120`	`// Give another partial implementation a chance to provide its own string representation`
0	`121`	`string? result = null;`
0	`122`	`AdditionalCustomizedToString(value, ref result);`
0	`123`	`if (result is not null)`
0	`124`	`{`
0	`125`	`return result;`
	`126`	`}`
	`127`
	`128`	`// Format arrays with their element type name and length`
0	`129`	`if (value is Array arr)`
0	`130`	`{`
0	`131`	`return $"{arr.GetType().GetElementType()}[{((Array)value).Length}]";`
	`132`	`}`
	`133`
	`134`	`// Format ICollections as the name and count`
0	`135`	`if (value is ICollection c)`
0	`136`	`{`
0	`137`	`return $"{c.GetType().Name}({c.Count})";`
	`138`	`}`
	`139`
	`140`	`// Format SafeHandles as their type, hash code, and pointer value`
0	`141`	`if (value is SafeHandle handle)`
0	`142`	`{`
0	`143`	`return $"{handle.GetType().Name}:{handle.GetHashCode()}(0x{handle.DangerousGetHandle():X})";`
	`144`	`}`
	`145`
	`146`	`// Format IntPtrs as hex`
0	`147`	`if (value is IntPtr)`
0	`148`	`{`
0	`149`	`return $"0x{value:X}";`
	`150`	`}`
	`151`
	`152`	`// If the string representation of the instance would just be its type name,`
	`153`	`// use its id instead.`
0	`154`	`string? toString = value.ToString();`
0	`155`	`if (toString == null \|\| toString == value.GetType().FullName)`
0	`156`	`{`
0	`157`	`return IdOf(value);`
	`158`	`}`
	`159`
	`160`	`// Otherwise, return the original object so that the caller does default formatting.`
0	`161`	`return value.ToString();`
0	`162`	`}`
	`163`
	`164`	`[NonEvent]`
	`165`	`private static string Format(FormattableString s)`
0	`166`	`{`
0	`167`	`switch (s.ArgumentCount)`
	`168`	`{`
0	`169`	`case 0: return s.Format;`
0	`170`	`case 1: return string.Format(s.Format, Format(s.GetArgument(0)));`
0	`171`	`case 2: return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)));`
0	`172`	`case 3: return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)), Format(s.GetA`
	`173`	`default:`
0	`174`	`string?[] formattedArgs = new string?[s.ArgumentCount];`
0	`175`	`for (int i = 0; i < formattedArgs.Length; i++)`
0	`176`	`{`
0	`177`	`formattedArgs[i] = Format(s.GetArgument(i));`
0	`178`	`}`
0	`179`	`return string.Format(s.Format, formattedArgs);`
	`180`	`}`
0	`181`	`}`
	`182`
	`183`	`static partial void AdditionalCustomizedToString(object value, ref string? result);`
	`184`	`#endregion`
	`185`
	`186`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`187`	`Justification = EventSourceSuppressMessage)]`
	`188`	`[NonEvent]`
	`189`	`private unsafe void WriteEvent(int eventId, string? arg1, string? arg2, int arg3)`
0	`190`	`{`
0	`191`	`arg1 ??= "";`
0	`192`	`arg2 ??= "";`
	`193`
0	`194`	`fixed (char* arg1Ptr = arg1)`
0	`195`	`fixed (char* arg2Ptr = arg2)`
0	`196`	`{`
	`197`	`const int NumEventDatas = 3;`
0	`198`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`199`
0	`200`	`descrs[0] = new EventData`
0	`201`	`{`
0	`202`	`DataPointer = (IntPtr)(arg1Ptr),`
0	`203`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`204`	`};`
0	`205`	`descrs[1] = new EventData`
0	`206`	`{`
0	`207`	`DataPointer = (IntPtr)(arg2Ptr),`
0	`208`	`Size = (arg2.Length + 1) * sizeof(char)`
0	`209`	`};`
0	`210`	`descrs[2] = new EventData`
0	`211`	`{`
0	`212`	`DataPointer = (IntPtr)(&arg3),`
0	`213`	`Size = sizeof(int)`
0	`214`	`};`
	`215`
0	`216`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`217`	`}`
0	`218`	`}`
	`219`	`}`
	`220`	`}`
	`221`

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.DumpBuffer.cs

#	Line	Line coverage
	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
	`3`
	`4`	`using System.Diagnostics.CodeAnalysis;`
	`5`	`using System.Diagnostics.Tracing;`
	`6`	`using System.Runtime.CompilerServices;`
	`7`
	`8`	`namespace System.Net`
	`9`	`{`
	`10`	`internal sealed partial class NetEventSource`
	`11`	`{`
	`12`	`private const int DumpArrayEventId = 4;`
	`13`	`private const int MaxDumpSize = 1024;`
	`14`
	`15`	`[NonEvent]`
	`16`	`public static void DumpBuffer(object? thisOrContextObject, byte[] buffer, [CallerMemberName] string? memberName`
	`17`	`DumpBuffer(thisOrContextObject, buffer.AsSpan(), memberName);`
	`18`
	`19`	`/// <summary>Logs the contents of a buffer.</summary>`
	`20`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`21`	`/// <param name="buffer">The buffer to be logged.</param>`
	`22`	`/// <param name="offset">The starting offset from which to log.</param>`
	`23`	`/// <param name="count">The number of bytes to log.</param>`
	`24`	`/// <param name="memberName">The calling member.</param>`
	`25`	`[NonEvent]`
	`26`	`public static void DumpBuffer(object? thisOrContextObject, byte[] buffer, int offset, int count, [CallerMemberNa`
	`27`	`DumpBuffer(thisOrContextObject, buffer.AsSpan(offset, count), memberName);`
	`28`
	`29`	`/// <summary>Logs the contents of a buffer.</summary>`
	`30`	/// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
	`31`	`/// <param name="buffer">The buffer to be logged.</param>`
	`32`	`/// <param name="memberName">The calling member.</param>`
	`33`	`[NonEvent]`
	`34`	`public static void DumpBuffer(object? thisOrContextObject, ReadOnlySpan<byte> buffer, [CallerMemberName] string?`
0	`35`	`Log.DumpBuffer(IdOf(thisOrContextObject), memberName, buffer.Slice(0, Math.Min(buffer.Length, MaxDumpSize)).`
	`36`
	`37`	`[Event(DumpArrayEventId, Level = EventLevel.Verbose)]`
	`38`	`private void DumpBuffer(string thisOrContextObject, string? memberName, byte[] buffer) =>`
0	`39`	`WriteEvent(DumpArrayEventId, thisOrContextObject, memberName ?? MissingMember, buffer);`
	`40`
	`41`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`42`	`Justification = EventSourceSuppressMessage)]`
	`43`	`[NonEvent]`
	`44`	`private unsafe void WriteEvent(int eventId, string? arg1, string? arg2, byte[]? arg3)`
0	`45`	`{`
0	`46`	`arg1 ??= "";`
0	`47`	`arg2 ??= "";`
0	`48`	`arg3 ??= Array.Empty<byte>();`
	`49`
0	`50`	`fixed (char* arg1Ptr = arg1)`
0	`51`	`fixed (char* arg2Ptr = arg2)`
0	`52`	`fixed (byte* arg3Ptr = arg3)`
0	`53`	`{`
0	`54`	`int bufferLength = arg3.Length;`
	`55`	`const int NumEventDatas = 4;`
0	`56`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`57`
0	`58`	`descrs[0] = new EventData`
0	`59`	`{`
0	`60`	`DataPointer = (IntPtr)arg1Ptr,`
0	`61`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`62`	`};`
0	`63`	`descrs[1] = new EventData`
0	`64`	`{`
0	`65`	`DataPointer = (IntPtr)arg2Ptr,`
0	`66`	`Size = (arg2.Length + 1) * sizeof(char)`
0	`67`	`};`
0	`68`	`descrs[2] = new EventData`
0	`69`	`{`
0	`70`	`DataPointer = (IntPtr)(&bufferLength),`
0	`71`	`Size = 4`
0	`72`	`};`
0	`73`	`descrs[3] = new EventData`
0	`74`	`{`
0	`75`	`DataPointer = (IntPtr)arg3Ptr,`
0	`76`	`Size = bufferLength`
0	`77`	`};`
	`78`
0	`79`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`80`	`}`
0	`81`	`}`
	`82`	`}`
	`83`	`}`
	`84`

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Security/NetEventSource.Security.Windows.cs

#	Line	Line coverage
	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
	`3`
	`4`	`using System.Diagnostics.CodeAnalysis;`
	`5`	`using System.Diagnostics.Tracing;`
	`6`	`using System.Net.Security;`
	`7`
	`8`	`namespace System.Net`
	`9`	`{`
	`10`	`internal sealed partial class NetEventSource`
	`11`	`{`
	`12`	`private const int EnumerateSecurityPackagesId = NextAvailableEventId;`
	`13`	`private const int SspiPackageNotFoundId = EnumerateSecurityPackagesId + 1;`
	`14`	`private const int AcquireDefaultCredentialId = SspiPackageNotFoundId + 1;`
	`15`	`private const int AcquireCredentialsHandleId = AcquireDefaultCredentialId + 1;`
	`16`	`private const int InitializeSecurityContextId = AcquireCredentialsHandleId + 1;`
	`17`	`private const int SecurityContextInputBufferId = InitializeSecurityContextId + 1;`
	`18`	`private const int SecurityContextInputBuffersId = SecurityContextInputBufferId + 1;`
	`19`	`private const int AcceptSecuritContextId = SecurityContextInputBuffersId + 1;`
	`20`	`private const int OperationReturnedSomethingId = AcceptSecuritContextId + 1;`
	`21`	`// Make sure to update the event IDs in NetEventSource.Security.cs if you add more events here`
	`22`
	`23`	`[Event(EnumerateSecurityPackagesId, Level = EventLevel.Informational)]`
	`24`	`public void EnumerateSecurityPackages(string? securityPackage) =>`
0	`25`	`WriteEvent(EnumerateSecurityPackagesId, securityPackage);`
	`26`
	`27`	`[Event(SspiPackageNotFoundId, Level = EventLevel.Informational)]`
	`28`	`public void SspiPackageNotFound(string packageName) =>`
0	`29`	`WriteEvent(SspiPackageNotFoundId, packageName);`
	`30`
	`31`	`[Event(AcquireDefaultCredentialId, Level = EventLevel.Informational)]`
	`32`	`public void AcquireDefaultCredential(string packageName, Interop.SspiCli.CredentialUse intent) =>`
0	`33`	`WriteEvent(AcquireDefaultCredentialId, packageName, intent);`
	`34`
	`35`	`[NonEvent]`
	`36`	`public void AcquireCredentialsHandle(string packageName, Interop.SspiCli.CredentialUse intent, object authdata)`
0	`37`	`AcquireCredentialsHandle(packageName, intent, IdOf(authdata));`
	`38`
	`39`	`[Event(AcquireCredentialsHandleId, Level = EventLevel.Informational)]`
	`40`	`public void AcquireCredentialsHandle(string packageName, Interop.SspiCli.CredentialUse intent, string authdata)`
0	`41`	`WriteEvent(AcquireCredentialsHandleId, packageName, (int)intent, authdata);`
	`42`
	`43`	`[NonEvent]`
	`44`	`public void InitializeSecurityContext(SafeFreeCredentials? credential, SafeDeleteContext? context, string? targe`
0	`45`	`InitializeSecurityContext(IdOf(credential), IdOf(context), targetName, inFlags);`
	`46`
	`47`	`[Event(InitializeSecurityContextId, Level = EventLevel.Informational)]`
	`48`	`private void InitializeSecurityContext(string credential, string context, string? targetName, Interop.SspiCli.Co`
0	`49`	`WriteEvent(InitializeSecurityContextId, credential, context, targetName, (int)inFlags);`
	`50`
	`51`	`[NonEvent]`
	`52`	`public void AcceptSecurityContext(SafeFreeCredentials? credential, SafeDeleteContext? context, Interop.SspiCli.C`
0	`53`	`AcceptSecurityContext(IdOf(credential), IdOf(context), inFlags);`
	`54`
	`55`	`[Event(AcceptSecuritContextId, Level = EventLevel.Informational)]`
	`56`	`private void AcceptSecurityContext(string credential, string context, Interop.SspiCli.ContextFlags inFlags) =>`
0	`57`	`WriteEvent(AcceptSecuritContextId, credential, context, (int)inFlags);`
	`58`
	`59`	`[Event(OperationReturnedSomethingId, Level = EventLevel.Informational, Message = "{0} returned {1}.")]`
	`60`	`public void OperationReturnedSomething(string operation, Interop.SECURITY_STATUS errorCode) =>`
0	`61`	`WriteEvent(OperationReturnedSomethingId, operation, errorCode);`
	`62`
	`63`	`[Event(SecurityContextInputBufferId, Level = EventLevel.Informational)]`
	`64`	`public void SecurityContextInputBuffer(string context, int inputBufferSize, int outputBufferSize, Interop.SECURI`
	`65`	`WriteEvent(SecurityContextInputBufferId, context, inputBufferSize, outputBufferSize, (int)errorCode);`
	`66`
	`67`	`[Event(SecurityContextInputBuffersId, Level = EventLevel.Informational)]`
	`68`	`public void SecurityContextInputBuffers(string context, int inputBuffersSize, int outputBufferSize, Interop.SECU`
0	`69`	`WriteEvent(SecurityContextInputBuffersId, context, inputBuffersSize, outputBufferSize, (int)errorCode);`
	`70`
	`71`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`72`	`Justification = EventSourceSuppressMessage)]`
	`73`	`[NonEvent]`
	`74`	`private unsafe void WriteEvent(int eventId, string? arg1, int arg2, int arg3, int arg4)`
0	`75`	`{`
0	`76`	`arg1 ??= "";`
	`77`
0	`78`	`fixed (char* arg1Ptr = arg1)`
0	`79`	`{`
	`80`	`const int NumEventDatas = 4;`
0	`81`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`82`
0	`83`	`descrs[0] = new EventData`
0	`84`	`{`
0	`85`	`DataPointer = (IntPtr)(arg1Ptr),`
0	`86`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`87`	`};`
0	`88`	`descrs[1] = new EventData`
0	`89`	`{`
0	`90`	`DataPointer = (IntPtr)(&arg2),`
0	`91`	`Size = sizeof(int)`
0	`92`	`};`
0	`93`	`descrs[2] = new EventData`
0	`94`	`{`
0	`95`	`DataPointer = (IntPtr)(&arg3),`
0	`96`	`Size = sizeof(int)`
0	`97`	`};`
0	`98`	`descrs[3] = new EventData`
0	`99`	`{`
0	`100`	`DataPointer = (IntPtr)(&arg4),`
0	`101`	`Size = sizeof(int)`
0	`102`	`};`
	`103`
0	`104`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`105`	`}`
0	`106`	`}`
	`107`
	`108`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`109`	`Justification = EventSourceSuppressMessage)]`
	`110`	`[NonEvent]`
	`111`	`private unsafe void WriteEvent(int eventId, string? arg1, int arg2, string? arg3)`
0	`112`	`{`
0	`113`	`arg1 ??= "";`
0	`114`	`arg3 ??= "";`
	`115`
0	`116`	`fixed (char* arg1Ptr = arg1)`
0	`117`	`fixed (char* arg3Ptr = arg3)`
0	`118`	`{`
	`119`	`const int NumEventDatas = 3;`
0	`120`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`121`
0	`122`	`descrs[0] = new EventData`
0	`123`	`{`
0	`124`	`DataPointer = (IntPtr)(arg1Ptr),`
0	`125`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`126`	`};`
0	`127`	`descrs[1] = new EventData`
0	`128`	`{`
0	`129`	`DataPointer = (IntPtr)(&arg2),`
0	`130`	`Size = sizeof(int)`
0	`131`	`};`
0	`132`	`descrs[2] = new EventData`
0	`133`	`{`
0	`134`	`DataPointer = (IntPtr)(arg3Ptr),`
0	`135`	`Size = (arg3.Length + 1) * sizeof(char)`
0	`136`	`};`
	`137`
0	`138`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`139`	`}`
0	`140`	`}`
	`141`
	`142`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`143`	`Justification = EventSourceSuppressMessage)]`
	`144`	`[NonEvent]`
	`145`	`private unsafe void WriteEvent(int eventId, string? arg1, string? arg2, string? arg3, int arg4)`
0	`146`	`{`
0	`147`	`arg1 ??= "";`
0	`148`	`arg2 ??= "";`
0	`149`	`arg3 ??= "";`
	`150`
0	`151`	`fixed (char* arg1Ptr = arg1)`
0	`152`	`fixed (char* arg2Ptr = arg2)`
0	`153`	`fixed (char* arg3Ptr = arg3)`
0	`154`	`{`
	`155`	`const int NumEventDatas = 4;`
0	`156`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`157`
0	`158`	`descrs[0] = new EventData`
0	`159`	`{`
0	`160`	`DataPointer = (IntPtr)(arg1Ptr),`
0	`161`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`162`	`};`
0	`163`	`descrs[1] = new EventData`
0	`164`	`{`
0	`165`	`DataPointer = (IntPtr)(arg2Ptr),`
0	`166`	`Size = (arg2.Length + 1) * sizeof(char)`
0	`167`	`};`
0	`168`	`descrs[2] = new EventData`
0	`169`	`{`
0	`170`	`DataPointer = (IntPtr)(arg3Ptr),`
0	`171`	`Size = (arg3.Length + 1) * sizeof(char)`
0	`172`	`};`
0	`173`	`descrs[3] = new EventData`
0	`174`	`{`
0	`175`	`DataPointer = (IntPtr)(&arg4),`
0	`176`	`Size = sizeof(int)`
0	`177`	`};`
	`178`
0	`179`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`180`	`}`
0	`181`	`}`
	`182`	`}`
	`183`	`}`
	`184`

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Net.Security/src/System/Net/Security/NetEventSource.Security.cs

#	Line	Line coverage
	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
	`3`
	`4`	`using System.Diagnostics.CodeAnalysis;`
	`5`	`using System.Diagnostics.Tracing;`
	`6`	`using System.IO;`
	`7`	`using System.Net.Security;`
	`8`	`using System.Net.Sockets;`
	`9`	`using System.Security.Authentication;`
	`10`	`using System.Security.Cryptography.X509Certificates;`
	`11`
	`12`	`namespace System.Net`
	`13`	`{`
	`14`	`[EventSource(Name = "Private.InternalDiagnostics.System.Net.Security")]`
	`15`	`internal sealed partial class NetEventSource`
	`16`	`{`
	`17`	`#if WINDOWS`
	`18`	`// More events are defined in NetEventSource.Security.Windows.cs`
	`19`	`private const int LocatingPrivateKeyId = OperationReturnedSomethingId + 1;`
	`20`	`#else`
	`21`	`private const int LocatingPrivateKeyId = NextAvailableEventId;`
	`22`	`#endif`
	`23`	`private const int CertIsType2Id = LocatingPrivateKeyId + 1;`
	`24`	`private const int FoundCertInStoreId = CertIsType2Id + 1;`
	`25`	`private const int NotFoundCertInStoreId = FoundCertInStoreId + 1;`
	`26`	`private const int RemoteCertificateId = NotFoundCertInStoreId + 1;`
	`27`	`private const int CertificateFromDelegateId = RemoteCertificateId + 1;`
	`28`	`private const int NoDelegateNoClientCertId = CertificateFromDelegateId + 1;`
	`29`	`private const int NoDelegateButClientCertId = NoDelegateNoClientCertId + 1;`
	`30`	`private const int AttemptingRestartUsingCertId = NoDelegateButClientCertId + 1;`
	`31`	`private const int NoIssuersTryAllCertsId = AttemptingRestartUsingCertId + 1;`
	`32`	`private const int LookForMatchingCertsId = NoIssuersTryAllCertsId + 1;`
	`33`	`private const int SelectedCertId = LookForMatchingCertsId + 1;`
	`34`	`private const int CertsAfterFilteringId = SelectedCertId + 1;`
	`35`	`private const int FindingMatchingCertsId = CertsAfterFilteringId + 1;`
	`36`	`private const int UsingCachedCredentialId = FindingMatchingCertsId + 1;`
	`37`	`private const int SspiSelectedCipherSuitId = UsingCachedCredentialId + 1;`
	`38`	`private const int RemoteCertificateErrorId = SspiSelectedCipherSuitId + 1;`
	`39`	`private const int RemoteVertificateValidId = RemoteCertificateErrorId + 1;`
	`40`	`private const int RemoteCertificateSuccessId = RemoteVertificateValidId + 1;`
	`41`	`private const int RemoteCertificateInvalidId = RemoteCertificateSuccessId + 1;`
	`42`	`private const int SslStreamCtorId = RemoteCertificateInvalidId + 1;`
	`43`	`private const int SentFrameId = SslStreamCtorId + 1;`
	`44`	`private const int ReceivedFrameId = SentFrameId + 1;`
	`45`	`private const int CertificateFromCertContextId = ReceivedFrameId + 1;`
	`46`
	`47`	`[NonEvent]`
	`48`	`public void SslStreamCtor(SslStream sslStream, Stream innerStream)`
0	`49`	`{`
0	`50`	`string? localId = null;`
0	`51`	`string? remoteId = null;`
	`52`
0	`53`	`if (innerStream is NetworkStream ns)`
0	`54`	`{`
	`55`	`try`
0	`56`	`{`
0	`57`	`localId = ns.Socket.LocalEndPoint?.ToString();`
0	`58`	`remoteId = ns.Socket.RemoteEndPoint?.ToString();`
0	`59`	`}`
0	`60`	`catch { };`
0	`61`	`}`
	`62`
0	`63`	`localId ??= IdOf(innerStream);`
	`64`
0	`65`	`SslStreamCtor(IdOf(sslStream), localId, remoteId);`
0	`66`	`}`
	`67`
	`68`	`[Event(SslStreamCtorId, Level = EventLevel.Informational)]`
	`69`	`private void SslStreamCtor(string thisOrContextObject, string? localId, string? remoteId) =>`
0	`70`	`WriteEvent(SslStreamCtorId, thisOrContextObject, localId, remoteId);`
	`71`
	`72`	`[NonEvent]`
	`73`	`public void LocatingPrivateKey(X509Certificate x509Certificate, object instance) =>`
0	`74`	`LocatingPrivateKey(x509Certificate.ToString(fVerbose: true), GetHashCode(instance));`
	`75`
	`76`	`[Event(LocatingPrivateKeyId, Level = EventLevel.Informational)]`
	`77`	`private void LocatingPrivateKey(string x509Certificate, int sslStreamHash) =>`
0	`78`	`WriteEvent(LocatingPrivateKeyId, x509Certificate, sslStreamHash);`
	`79`
	`80`	`[NonEvent]`
	`81`	`public void CertIsType2(object instance) =>`
0	`82`	`CertIsType2(GetHashCode(instance));`
	`83`
	`84`	`[Event(CertIsType2Id, Level = EventLevel.Informational)]`
	`85`	`private void CertIsType2(int sslStreamHash) =>`
0	`86`	`WriteEvent(CertIsType2Id, sslStreamHash);`
	`87`
	`88`	`[NonEvent]`
	`89`	`public void FoundCertInStore(bool serverMode, object instance) =>`
0	`90`	`FoundCertInStore(serverMode ? "LocalMachine" : "CurrentUser", GetHashCode(instance));`
	`91`
	`92`	`[Event(FoundCertInStoreId, Level = EventLevel.Informational)]`
	`93`	`private void FoundCertInStore(string store, int sslStreamHash) =>`
0	`94`	`WriteEvent(FoundCertInStoreId, store, sslStreamHash);`
	`95`
	`96`	`[NonEvent]`
	`97`	`public void NotFoundCertInStore(object instance) =>`
0	`98`	`NotFoundCertInStore(GetHashCode(instance));`
	`99`
	`100`	`[Event(NotFoundCertInStoreId, Level = EventLevel.Informational)]`
	`101`	`private void NotFoundCertInStore(int sslStreamHash) =>`
0	`102`	`WriteEvent(NotFoundCertInStoreId, sslStreamHash);`
	`103`
	`104`	`[NonEvent]`
	`105`	`public void RemoteCertificate(X509Certificate? remoteCertificate) =>`
0	`106`	`RemoteCertificate(remoteCertificate?.ToString(fVerbose: true));`
	`107`
	`108`	`[Event(RemoteCertificateId, Level = EventLevel.Informational)]`
	`109`	`private void RemoteCertificate(string? remoteCertificate) =>`
0	`110`	`WriteEvent(RemoteCertificateId, remoteCertificate);`
	`111`
	`112`	`[NonEvent]`
	`113`	`public void CertificateFromDelegate(SslStream SslStream) =>`
0	`114`	`CertificateFromDelegate(GetHashCode(SslStream));`
	`115`
	`116`	`[Event(CertificateFromDelegateId, Level = EventLevel.Informational)]`
	`117`	`private void CertificateFromDelegate(int sslStreamHash) =>`
0	`118`	`WriteEvent(CertificateFromDelegateId, sslStreamHash);`
	`119`
	`120`	`[NonEvent]`
	`121`	`public void NoDelegateNoClientCert(SslStream SslStream) =>`
0	`122`	`NoDelegateNoClientCert(GetHashCode(SslStream));`
	`123`
	`124`	`[Event(NoDelegateNoClientCertId, Level = EventLevel.Informational)]`
	`125`	`private void NoDelegateNoClientCert(int sslStreamHash) =>`
0	`126`	`WriteEvent(NoDelegateNoClientCertId, sslStreamHash);`
	`127`
	`128`	`[NonEvent]`
	`129`	`public void NoDelegateButClientCert(SslStream SslStream) =>`
0	`130`	`NoDelegateButClientCert(GetHashCode(SslStream));`
	`131`
	`132`	`[Event(NoDelegateButClientCertId, Level = EventLevel.Informational)]`
	`133`	`private void NoDelegateButClientCert(int sslStreamHash) =>`
0	`134`	`WriteEvent(NoDelegateButClientCertId, sslStreamHash);`
	`135`
	`136`	`[NonEvent]`
	`137`	`public void AttemptingRestartUsingCert(X509Certificate? clientCertificate, SslStream SslStream) =>`
0	`138`	`AttemptingRestartUsingCert(clientCertificate?.ToString(fVerbose: true), GetHashCode(SslStream));`
	`139`
	`140`	`[Event(AttemptingRestartUsingCertId, Level = EventLevel.Informational)]`
	`141`	`private void AttemptingRestartUsingCert(string? clientCertificate, int sslStreamHash) =>`
0	`142`	`WriteEvent(AttemptingRestartUsingCertId, clientCertificate, sslStreamHash);`
	`143`
	`144`	`[NonEvent]`
	`145`	`public void NoIssuersTryAllCerts(SslStream SslStream) =>`
0	`146`	`NoIssuersTryAllCerts(GetHashCode(SslStream));`
	`147`
	`148`	`[Event(NoIssuersTryAllCertsId, Level = EventLevel.Informational)]`
	`149`	`private void NoIssuersTryAllCerts(int sslStreamHash) =>`
0	`150`	`WriteEvent(NoIssuersTryAllCertsId, sslStreamHash);`
	`151`
	`152`	`[NonEvent]`
	`153`	`public void LookForMatchingCerts(int issuersCount, SslStream SslStream) =>`
0	`154`	`LookForMatchingCerts(issuersCount, GetHashCode(SslStream));`
	`155`
	`156`	`[Event(LookForMatchingCertsId, Level = EventLevel.Informational)]`
	`157`	`private void LookForMatchingCerts(int issuersCount, int sslStreamHash) =>`
0	`158`	`WriteEvent(LookForMatchingCertsId, issuersCount, sslStreamHash);`
	`159`
	`160`	`[NonEvent]`
	`161`	`public void SelectedCert(X509Certificate clientCertificate, SslStream SslStream) =>`
0	`162`	`SelectedCert(clientCertificate?.ToString(fVerbose: true), GetHashCode(SslStream));`
	`163`
	`164`	`[Event(SelectedCertId, Level = EventLevel.Informational)]`
	`165`	`private void SelectedCert(string? clientCertificate, int sslStreamHash) =>`
0	`166`	`WriteEvent(SelectedCertId, clientCertificate, sslStreamHash);`
	`167`
	`168`	`[NonEvent]`
	`169`	`public void CertsAfterFiltering(int filteredCertsCount, SslStream SslStream) =>`
0	`170`	`CertsAfterFiltering(filteredCertsCount, GetHashCode(SslStream));`
	`171`
	`172`	`[Event(CertsAfterFilteringId, Level = EventLevel.Informational)]`
	`173`	`private void CertsAfterFiltering(int filteredCertsCount, int sslStreamHash) =>`
0	`174`	`WriteEvent(CertsAfterFilteringId, filteredCertsCount, sslStreamHash);`
	`175`
	`176`	`[NonEvent]`
	`177`	`public void FindingMatchingCerts(SslStream SslStream) =>`
0	`178`	`FindingMatchingCerts(GetHashCode(SslStream));`
	`179`
	`180`	`[Event(FindingMatchingCertsId, Level = EventLevel.Informational)]`
	`181`	`private void FindingMatchingCerts(int sslStreamHash) =>`
0	`182`	`WriteEvent(FindingMatchingCertsId, sslStreamHash);`
	`183`
	`184`	`[NonEvent]`
	`185`	`public void UsingCachedCredential(SslStream SslStream) =>`
0	`186`	`UsingCachedCredential(GetHashCode(SslStream));`
	`187`
	`188`	`[Event(UsingCachedCredentialId, Level = EventLevel.Informational)]`
	`189`	`private void UsingCachedCredential(int sslStreamHash) =>`
0	`190`	`WriteEvent(UsingCachedCredentialId, sslStreamHash);`
	`191`
	`192`	`#pragma warning disable SYSLIB0058 // Use NegotiatedCipherSuite.`
	`193`	`[Event(SspiSelectedCipherSuitId, Level = EventLevel.Informational)]`
	`194`	`public void SspiSelectedCipherSuite(`
	`195`	`string process,`
	`196`	`SslProtocols sslProtocol,`
	`197`	`CipherAlgorithmType cipherAlgorithm,`
	`198`	`int cipherStrength,`
	`199`	`HashAlgorithmType hashAlgorithm,`
	`200`	`int hashStrength,`
	`201`	`ExchangeAlgorithmType keyExchangeAlgorithm,`
	`202`	`int keyExchangeStrength)`
0	`203`	`{`
0	`204`	`WriteEvent(SspiSelectedCipherSuitId,`
0	`205`	`process, (int)sslProtocol, (int)cipherAlgorithm, cipherStrength,`
0	`206`	`(int)hashAlgorithm, hashStrength, (int)keyExchangeAlgorithm, keyExchangeStrength);`
0	`207`	`}`
	`208`	`#pragma warning restore SYSLIB0058 // Use NegotiatedCipherSuite.`
	`209`
	`210`	`[NonEvent]`
	`211`	`public void RemoteCertificateError(object sender, string message) =>`
0	`212`	`RemoteCertificateError(GetHashCode(sender), message);`
	`213`
	`214`	`[Event(RemoteCertificateErrorId, Level = EventLevel.Verbose)]`
	`215`	`private void RemoteCertificateError(int sslStreamHash, string message) =>`
0	`216`	`WriteEvent(RemoteCertificateErrorId, sslStreamHash, message);`
	`217`
	`218`	`[NonEvent]`
	`219`	`public void RemoteCertDeclaredValid(object sender) =>`
0	`220`	`RemoteCertDeclaredValid(GetHashCode(sender));`
	`221`
	`222`	`[Event(RemoteVertificateValidId, Level = EventLevel.Verbose)]`
	`223`	`private void RemoteCertDeclaredValid(int sslStreamHash) =>`
0	`224`	`WriteEvent(RemoteVertificateValidId, sslStreamHash);`
	`225`
	`226`	`[NonEvent]`
	`227`	`public void RemoteCertHasNoErrors(object sender) =>`
0	`228`	`RemoteCertHasNoErrors(GetHashCode(sender));`
	`229`
	`230`	`[Event(RemoteCertificateSuccessId, Level = EventLevel.Verbose)]`
	`231`	`private void RemoteCertHasNoErrors(int sslStreamHash) =>`
0	`232`	`WriteEvent(RemoteCertificateSuccessId, sslStreamHash);`
	`233`
	`234`	`[NonEvent]`
	`235`	`public void RemoteCertUserDeclaredInvalid(object sender) =>`
0	`236`	`RemoteCertUserDeclaredInvalid(GetHashCode(sender));`
	`237`
	`238`	`[Event(RemoteCertificateInvalidId, Level = EventLevel.Verbose)]`
	`239`	`private void RemoteCertUserDeclaredInvalid(int sslStreamHash) =>`
0	`240`	`WriteEvent(RemoteCertificateInvalidId, sslStreamHash);`
	`241`
	`242`	`[NonEvent]`
	`243`	`public void SentFrame(SslStream sslStream, ReadOnlySpan<byte> frame)`
0	`244`	`{`
0	`245`	`TlsFrameHelper.TlsFrameInfo info = default;`
0	`246`	`bool isComplete = TlsFrameHelper.TryGetFrameInfo(frame, ref info);`
0	`247`	`SentFrame(IdOf(sslStream), info.ToString(), isComplete ? 1 : 0);`
0	`248`	`}`
	`249`
	`250`	`[Event(SentFrameId, Level = EventLevel.Verbose)]`
	`251`	`private void SentFrame(string sslStream, string tlsFrame, int isComplete) =>`
0	`252`	`WriteEvent(SentFrameId, sslStream, tlsFrame, isComplete);`
	`253`
	`254`	`[NonEvent]`
	`255`	`public void ReceivedFrame(SslStream sslStream, TlsFrameHelper.TlsFrameInfo frameInfo) =>`
0	`256`	`ReceivedFrame(IdOf(sslStream), frameInfo.ToString(), 1);`
	`257`
	`258`	`[NonEvent]`
	`259`	`public void ReceivedFrame(SslStream sslStream, ReadOnlySpan<byte> frame)`
	`260`	`{`
	`261`	`TlsFrameHelper.TlsFrameInfo info = default;`
	`262`	`bool isComplete = TlsFrameHelper.TryGetFrameInfo(frame, ref info);`
	`263`	`ReceivedFrame(IdOf(sslStream), info.ToString(), isComplete ? 1 : 0);`
	`264`	`}`
	`265`
	`266`	`[Event(ReceivedFrameId, Level = EventLevel.Verbose)]`
	`267`	`private void ReceivedFrame(string sslStream, string tlsFrame, int isComplete) =>`
0	`268`	`WriteEvent(ReceivedFrameId, sslStream, tlsFrame, isComplete);`
	`269`
	`270`	`[NonEvent]`
	`271`	`public void CertificateFromCertContext(SslStream sslStream) =>`
0	`272`	`CertificateFromCertContext(GetHashCode(sslStream));`
	`273`
	`274`	`[Event(CertificateFromCertContextId, Level = EventLevel.Informational)]`
	`275`	`public void CertificateFromCertContext(int sslStreamHash) =>`
0	`276`	`WriteEvent(CertificateFromCertContextId, sslStreamHash);`
	`277`
	`278`	`static partial void AdditionalCustomizedToString(object value, ref string? result)`
0	`279`	`{`
0	`280`	`if (value is X509Certificate cert)`
0	`281`	`{`
0	`282`	`result = cert.ToString(fVerbose: true);`
0	`283`	`}`
0	`284`	`}`
	`285`
	`286`	`[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",`
	`287`	`Justification = EventSourceSuppressMessage)]`
	`288`	`[NonEvent]`
	`289`	`private unsafe void WriteEvent(int eventId, string arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int a`
0	`290`	`{`
0	`291`	`arg1 ??= "";`
	`292`
0	`293`	`fixed (char* arg1Ptr = arg1)`
0	`294`	`{`
	`295`	`const int NumEventDatas = 8;`
0	`296`	`EventData* descrs = stackalloc EventData[NumEventDatas];`
	`297`
0	`298`	`descrs[0] = new EventData`
0	`299`	`{`
0	`300`	`DataPointer = (IntPtr)(arg1Ptr),`
0	`301`	`Size = (arg1.Length + 1) * sizeof(char)`
0	`302`	`};`
0	`303`	`descrs[1] = new EventData`
0	`304`	`{`
0	`305`	`DataPointer = (IntPtr)(&arg2),`
0	`306`	`Size = sizeof(int)`
0	`307`	`};`
0	`308`	`descrs[2] = new EventData`
0	`309`	`{`
0	`310`	`DataPointer = (IntPtr)(&arg3),`
0	`311`	`Size = sizeof(int)`
0	`312`	`};`
0	`313`	`descrs[3] = new EventData`
0	`314`	`{`
0	`315`	`DataPointer = (IntPtr)(&arg4),`
0	`316`	`Size = sizeof(int)`
0	`317`	`};`
0	`318`	`descrs[4] = new EventData`
0	`319`	`{`
0	`320`	`DataPointer = (IntPtr)(&arg5),`
0	`321`	`Size = sizeof(int)`
0	`322`	`};`
0	`323`	`descrs[5] = new EventData`
0	`324`	`{`
0	`325`	`DataPointer = (IntPtr)(&arg6),`
0	`326`	`Size = sizeof(int)`
0	`327`	`};`
0	`328`	`descrs[6] = new EventData`
0	`329`	`{`
0	`330`	`DataPointer = (IntPtr)(&arg7),`
0	`331`	`Size = sizeof(int)`
0	`332`	`};`
0	`333`	`descrs[7] = new EventData`
0	`334`	`{`
0	`335`	`DataPointer = (IntPtr)(&arg8),`
0	`336`	`Size = sizeof(int)`
0	`337`	`};`
	`338`
0	`339`	`WriteEventCore(eventId, NumEventDatas, descrs);`
0	`340`	`}`
0	`341`	`}`
	`342`	`}`
	`343`	`}`
	`344`

Methods/Properties