logging

package
v0.0.0-...-28b6034 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 29, 2022 License: MIT Imports: 7 Imported by: 0

Documentation

Overview

Package logging defines a logging interface for quic-go. This package should not be considered stable

Index

Constants

View Source 
const (
	// StreamTypeUni is a unidirectional stream
	StreamTypeUni = protocol.StreamTypeUni
	// StreamTypeBidi is a bidirectional stream
	StreamTypeBidi = protocol.StreamTypeBidi
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AckFrame 

type AckFrame = wire.AckFrame

An AckFrame is an ACK frame.

type AckRange 

type AckRange = wire.AckRange

The AckRange is used within the AckFrame. It is a range of packet numbers that is being acknowledged.

type ApplicationError 

type ApplicationError = qerr.TransportErrorCode

An ApplicationError is an application-defined error code.

type ByteCount 

type ByteCount = protocol.ByteCount

A ByteCount is used to count bytes.

type CongestionState 

type CongestionState uint8
const (
	// CongestionStateSlowStart is the slow start phase of Reno / Cubic
	CongestionStateSlowStart CongestionState = iota
	// CongestionStateCongestionAvoidance is the slow start phase of Reno / Cubic
	CongestionStateCongestionAvoidance
	// CongestionStateRecovery is the recovery phase of Reno / Cubic
	CongestionStateRecovery
	// CongestionStateApplicationLimited means that the congestion controller is application limited
	CongestionStateApplicationLimited
)

type ConnectionCloseFrame 

type ConnectionCloseFrame = wire.ConnectionCloseFrame

A ConnectionCloseFrame is a CONNECTION_CLOSE frame.

type ConnectionID 

type ConnectionID = protocol.ConnectionID

A ConnectionID is a QUIC Connection ID.

type ConnectionTracer 

type ConnectionTracer interface {
	StartedConnection(local, remote net.Addr, srcConnID, destConnID ConnectionID)
	NegotiatedVersion(chosen VersionNumber, clientVersions, serverVersions []VersionNumber)
	ClosedConnection(error)
	SentTransportParameters(*TransportParameters)
	ReceivedTransportParameters(*TransportParameters)
	RestoredTransportParameters(parameters *TransportParameters) // for 0-RTT
	SentPacket(hdr *ExtendedHeader, size ByteCount, ack *AckFrame, frames []Frame)
	ReceivedVersionNegotiationPacket(*Header, []VersionNumber)
	ReceivedRetry(*Header)
	ReceivedPacket(hdr *ExtendedHeader, size ByteCount, frames []Frame)
	BufferedPacket(PacketType)
	DroppedPacket(PacketType, ByteCount, PacketDropReason)
	UpdatedMetrics(rttStats *RTTStats, cwnd, bytesInFlight ByteCount, packetsInFlight int)
	AcknowledgedPacket(EncryptionLevel, PacketNumber)
	LostPacket(EncryptionLevel, PacketNumber, PacketLossReason)
	UpdatedCongestionState(CongestionState)
	UpdatedPTOCount(value uint32)
	UpdatedKeyFromTLS(EncryptionLevel, Perspective)
	UpdatedKey(generation KeyPhase, remote bool)
	DroppedEncryptionLevel(EncryptionLevel)
	DroppedKey(generation KeyPhase)
	SetLossTimer(TimerType, EncryptionLevel, time.Time)
	LossTimerExpired(TimerType, EncryptionLevel)
	LossTimerCanceled()
	// Close is called when the connection is closed.
	Close()
	Debug(name, msg string)
}

A ConnectionTracer records events.

func NewMultiplexedConnectionTracer 

func NewMultiplexedConnectionTracer(tracers ...ConnectionTracer) ConnectionTracer

NewMultiplexedConnectionTracer creates a new connection tracer that multiplexes events to multiple tracers.

type CryptoFrame 

type CryptoFrame struct {
	Offset ByteCount
	Length ByteCount
}

A CryptoFrame is a CRYPTO frame.

type DataBlockedFrame 

type DataBlockedFrame = wire.DataBlockedFrame

A DataBlockedFrame is a DATA_BLOCKED frame.

type DatagramFrame 

type DatagramFrame struct {
	Length ByteCount
}

A DatagramFrame is a DATAGRAM frame.

type EncryptionLevel 

type EncryptionLevel = protocol.EncryptionLevel

The EncryptionLevel is the encryption level of a packet. 

const (
	// EncryptionInitial is the Initial encryption level
	EncryptionInitial EncryptionLevel = protocol.EncryptionInitial
	// EncryptionHandshake is the Handshake encryption level
	EncryptionHandshake EncryptionLevel = protocol.EncryptionHandshake
	// Encryption1RTT is the 1-RTT encryption level
	Encryption1RTT EncryptionLevel = protocol.Encryption1RTT
	// Encryption0RTT is the 0-RTT encryption level
	Encryption0RTT EncryptionLevel = protocol.Encryption0RTT
)

type ExtendedHeader 

type ExtendedHeader = wire.ExtendedHeader

The ExtendedHeader is the QUIC packet header, after removing header protection.

type Frame 

type Frame interface{}

A Frame is a QUIC frame

type HandshakeDoneFrame 

type HandshakeDoneFrame = wire.HandshakeDoneFrame

A HandshakeDoneFrame is a HANDSHAKE_DONE frame. 

type Header = wire.Header

The Header is the QUIC packet header, before removing header protection.

type KeyPhase 

type KeyPhase = protocol.KeyPhase

The KeyPhase is the key phase of the 1-RTT keys.

type KeyPhaseBit 

type KeyPhaseBit = protocol.KeyPhaseBit

The KeyPhaseBit is the value of the key phase bit of the 1-RTT packets. 

const (
	// KeyPhaseZero is key phase bit 0
	KeyPhaseZero KeyPhaseBit = protocol.KeyPhaseZero
	// KeyPhaseOne is key phase bit 1
	KeyPhaseOne KeyPhaseBit = protocol.KeyPhaseOne
)

type MaxDataFrame 

type MaxDataFrame = wire.MaxDataFrame

A MaxDataFrame is a MAX_DATA frame.

type MaxStreamDataFrame 

type MaxStreamDataFrame = wire.MaxStreamDataFrame

A MaxStreamDataFrame is a MAX_STREAM_DATA frame.

type MaxStreamsFrame 

type MaxStreamsFrame = wire.MaxStreamsFrame

A MaxStreamsFrame is a MAX_STREAMS_FRAME.

type NewConnectionIDFrame 

type NewConnectionIDFrame = wire.NewConnectionIDFrame

A NewConnectionIDFrame is a NEW_CONNECTION_ID frame.

type NewTokenFrame 

type NewTokenFrame = wire.NewTokenFrame

A NewTokenFrame is a NEW_TOKEN frame.

type PacketDropReason 

type PacketDropReason uint8
const (
	// PacketDropKeyUnavailable is used when a packet is dropped because keys are unavailable
	PacketDropKeyUnavailable PacketDropReason = iota
	// PacketDropUnknownConnectionID is used when a packet is dropped because the connection ID is unknown
	PacketDropUnknownConnectionID
	// PacketDropHeaderParseError is used when a packet is dropped because header parsing failed
	PacketDropHeaderParseError
	// PacketDropPayloadDecryptError is used when a packet is dropped because decrypting the payload failed
	PacketDropPayloadDecryptError
	// PacketDropProtocolViolation is used when a packet is dropped due to a protocol violation
	PacketDropProtocolViolation
	// PacketDropDOSPrevention is used when a packet is dropped to mitigate a DoS attack
	PacketDropDOSPrevention
	// PacketDropUnsupportedVersion is used when a packet is dropped because the version is not supported
	PacketDropUnsupportedVersion
	// PacketDropUnexpectedPacket is used when an unexpected packet is received
	PacketDropUnexpectedPacket
	// PacketDropUnexpectedSourceConnectionID is used when a packet with an unexpected source connection ID is received
	PacketDropUnexpectedSourceConnectionID
	// PacketDropUnexpectedVersion is used when a packet with an unexpected version is received
	PacketDropUnexpectedVersion
	// PacketDropDuplicate is used when a duplicate packet is received
	PacketDropDuplicate
)

type PacketLossReason 

type PacketLossReason uint8
const (
	// PacketLossReorderingThreshold: when a packet is deemed lost due to reordering threshold
	PacketLossReorderingThreshold PacketLossReason = iota
	// PacketLossTimeThreshold: when a packet is deemed lost due to time threshold
	PacketLossTimeThreshold
)

type PacketNumber 

type PacketNumber = protocol.PacketNumber

The PacketNumber is the packet number of a packet.

type PacketType 

type PacketType uint8

PacketType is the packet type of a QUIC packet 

const (
	// PacketTypeInitial is the packet type of an Initial packet
	PacketTypeInitial PacketType = iota
	// PacketTypeHandshake is the packet type of a Handshake packet
	PacketTypeHandshake
	// PacketTypeRetry is the packet type of a Retry packet
	PacketTypeRetry
	// PacketType0RTT is the packet type of a 0-RTT packet
	PacketType0RTT
	// PacketTypeVersionNegotiation is the packet type of a Version Negotiation packet
	PacketTypeVersionNegotiation
	// PacketType1RTT is a 1-RTT packet
	PacketType1RTT
	// PacketTypeStatelessReset is a stateless reset
	PacketTypeStatelessReset
	// PacketTypeNotDetermined is the packet type when it could not be determined
	PacketTypeNotDetermined
)

func PacketTypeFromHeader 

func PacketTypeFromHeader(hdr *Header) PacketType

PacketTypeFromHeader determines the packet type from a *wire.Header.

type PathChallengeFrame 

type PathChallengeFrame = wire.PathChallengeFrame

A PathChallengeFrame is a PATH_CHALLENGE frame.

type PathResponseFrame 

type PathResponseFrame = wire.PathResponseFrame

A PathResponseFrame is a PATH_RESPONSE frame.

type Perspective 

type Perspective = protocol.Perspective

The Perspective is the role of a QUIC endpoint (client or server). 

const (
	// PerspectiveServer is used for a QUIC server
	PerspectiveServer Perspective = protocol.PerspectiveServer
	// PerspectiveClient is used for a QUIC client
	PerspectiveClient Perspective = protocol.PerspectiveClient
)

type PingFrame 

type PingFrame = wire.PingFrame

A PingFrame is a PING frame.

type PreferredAddress 

type PreferredAddress = wire.PreferredAddress

The PreferredAddress is the preferred address sent in the transport parameters.

type RTTStats 

type RTTStats = utils.RTTStats

The RTTStats contain statistics used by the congestion controller.

type ResetStreamFrame 

type ResetStreamFrame = wire.ResetStreamFrame

A ResetStreamFrame is a RESET_STREAM frame.

type RetireConnectionIDFrame 

type RetireConnectionIDFrame = wire.RetireConnectionIDFrame

A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame.

type StatelessResetToken 

type StatelessResetToken = protocol.StatelessResetToken

A StatelessResetToken is a stateless reset token.

type StopSendingFrame 

type StopSendingFrame = wire.StopSendingFrame

A StopSendingFrame is a STOP_SENDING frame.

type StreamDataBlockedFrame 

type StreamDataBlockedFrame = wire.StreamDataBlockedFrame

A StreamDataBlockedFrame is a STREAM_DATA_BLOCKED frame.

type StreamFrame 

type StreamFrame struct {
	StreamID StreamID
	Offset   ByteCount
	Length   ByteCount
	Fin      bool
}

A StreamFrame is a STREAM frame.

type StreamID 

type StreamID = protocol.StreamID

The StreamID is the stream ID.

type StreamNum 

type StreamNum = protocol.StreamNum

The StreamNum is the number of the stream.

type StreamType 

type StreamType = protocol.StreamType

The StreamType is the type of the stream (unidirectional or bidirectional).

type StreamsBlockedFrame 

type StreamsBlockedFrame = wire.StreamsBlockedFrame

A StreamsBlockedFrame is a STREAMS_BLOCKED frame.

type TimeoutReason 

type TimeoutReason uint8

TimeoutReason is the reason why a connection is closed 

const (
	// TimeoutReasonHandshake is used when the connection is closed due to a handshake timeout
	// This reason is not defined in the qlog draft, but very useful for debugging.
	TimeoutReasonHandshake TimeoutReason = iota
	// TimeoutReasonIdle is used when the connection is closed due to an idle timeout
	// This reason is not defined in the qlog draft, but very useful for debugging.
	TimeoutReasonIdle
)

type TimerType 

type TimerType uint8

TimerType is the type of the loss detection timer 

const (
	// TimerTypeACK is the timer type for the early retransmit timer
	TimerTypeACK TimerType = iota
	// TimerTypePTO is the timer type for the PTO retransmit timer
	TimerTypePTO
)

type Tracer 

type Tracer interface {
	// TracerForConnection requests a new tracer for a connection.
	// The ODCID is the original destination connection ID:
	// The destination connection ID that the client used on the first Initial packet it sent on this connection.
	// If nil is returned, tracing will be disabled for this connection.
	TracerForConnection(ctx context.Context, p Perspective, odcid ConnectionID) ConnectionTracer

	SentPacket(net.Addr, *Header, ByteCount, []Frame)
	DroppedPacket(net.Addr, PacketType, ByteCount, PacketDropReason)
}

A Tracer traces events.

func NewMultiplexedTracer 

func NewMultiplexedTracer(tracers ...Tracer) Tracer

NewMultiplexedTracer creates a new tracer that multiplexes events to multiple tracers.

type TransportError 

type TransportError = qerr.TransportErrorCode

A TransportError is a transport-level error code.

type TransportParameters 

type TransportParameters = wire.TransportParameters

The TransportParameters are QUIC transport parameters.

type VersionNumber 

type VersionNumber = protocol.VersionNumber

The VersionNumber is the QUIC version.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.