Esempio n. 1
0
 internal QuicEvent(QuicEventId id, QuicObjectType objectType, Timestamp timestamp, ushort processor, uint processId, uint threadId, int pointerSize, ulong objectPointer = 0)
 {
     EventId       = id;
     ObjectType    = objectType;
     TimeStamp     = timestamp;
     Processor     = processor;
     ProcessId     = processId;
     ThreadId      = threadId;
     PointerSize   = pointerSize;
     ObjectPointer = objectPointer;
 }
Esempio n. 2
0
 internal QuicConnectionCreatedEvent(QuicEventId id, Timestamp timestamp, ushort processor, uint processId, uint threadId, int pointerSize, ulong objectPointer, uint isServer, ulong correlationId) :
     base(id, QuicObjectType.Connection, timestamp, processor, processId, threadId, pointerSize, objectPointer)
 {
     IsServer      = isServer;
     CorrelationId = correlationId;
 }
Esempio n. 3
0
 internal QuicConnectionMessageEvent(QuicEventId id, Timestamp timestamp, ushort processor, uint processId, uint threadId, int pointerSize, ulong objectPointer, string message) :
     base(id, QuicObjectType.Connection, timestamp, processor, processId, threadId, pointerSize, objectPointer)
 {
     Message = message;
 }
Esempio n. 4
0
 internal QuicLibraryMessageEvent(QuicEventId id, Timestamp timestamp, ushort processor, uint processId, uint threadId, int pointerSize, string message) :
     base(id, QuicObjectType.Global, timestamp, processor, processId, threadId, pointerSize)
 {
     Message = message;
 }
Esempio n. 5
0
        private static object?DecodePayload(QuicEventId id, ReadOnlySpan <byte> data, int pointerSize)
        {
            switch (id)
            {
            case QuicEventId.ApiEnter:
                return(new QuicApiEnterEtwPayload(data, pointerSize));

            case QuicEventId.ApiExitStatus:
                return(new QuicApiExitStatusEtwPayload(data));

            case QuicEventId.WorkerCreated:
                return(new QuicWorkerCreatedEtwPayload(data, pointerSize));

            case QuicEventId.WorkerActivityStateUpdated:
                return(new QuicWorkerActivityStateUpdatedEtwPayload(data));

            case QuicEventId.WorkerQueueDelayUpdated:
                return(new QuicWorkerQueueDelayUpdatedEtwPayload(data));

            case QuicEventId.ConnCreated:
            case QuicEventId.ConnRundown:
                return(new QuicConnectionCreatedEtwPayload(data));

            case QuicEventId.ConnScheduleState:
                return(new QuicConnectionScheduleStateEtwPayload(data));

            case QuicEventId.ConnExecOper:
                return(new QuicConnectionExecOperEtwPayload(data));

            case QuicEventId.ConnExecApiOper:
                return(new QuicConnectionExecApiOperEtwPayload(data));

            case QuicEventId.ConnExecTimerOper:
                return(new QuicConnectionExecTimerOperEtwPayload(data));

            case QuicEventId.ConnAssignWorker:
                return(new QuicConnectionAssignWorkerEtwPayload(data, pointerSize));

            case QuicEventId.ConnTransportShutdown:
                return(new QuicConnectionTransportShutdownEtwPayload(data));

            case QuicEventId.ConnAppShutdown:
                return(new QuicConnectionAppShutdownEtwPayload(data));

            case QuicEventId.ConnOutFlowStats:
                return(new QuicConnectionOutFlowStatsEtwPayload(data));

            case QuicEventId.ConnOutFlowBlocked:
                return(new QuicConnectionOutFlowBlockedEtwPayload(data));

            case QuicEventId.ConnInFlowStats:
                return(new QuicConnectionInFlowStatsEtwPayload(data));

            case QuicEventId.ConnStats:
                return(new QuicConnectionStatsEtwPayload(data));

            case QuicEventId.ConnOutFlowStreamStats:
                return(new QuicConnectionOutFlowStreamStatsEtwPayload(data));

            case QuicEventId.StreamCreated:
            case QuicEventId.StreamRundown:
                return(new QuicStreamCreatedEtwPayload(data, pointerSize));

            case QuicEventId.StreamOutFlowBlocked:
                return(new QuicStreamOutFlowBlockedEtwPayload(data));

            case QuicEventId.DatapathSend:
                return(new QuicDatapathSendEtwPayload(data));

            case QuicEventId.DatapathRecv:
                return(new QuicDatapathRecvEtwPayload(data));

            default:
                return(null);
            }
        }