logging

package
v0.29.102 Latest Latest
Warning

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

Go to latest
Published: Oct 16, 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 ArbitraryLenConnectionID

type ArbitraryLenConnectionID = protocol.ArbitraryLenConnectionID

An ArbitraryLenConnectionID is a QUIC Connection ID that can be up to 255 bytes long.

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(dest, src ArbitraryLenConnectionID, _ []VersionNumber)
	ReceivedRetry(*Header)
	ReceivedLongHeaderPacket(hdr *ExtendedHeader, size ByteCount, frames []Frame)
	ReceivedShortHeaderPacket(hdr *ShortHeader, size ByteCount, frames []Frame)
	BufferedPacket(PacketType, ByteCount)
	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 Long Header 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 NullConnectionTracer

type NullConnectionTracer struct{}

The NullConnectionTracer is a ConnectionTracer that does nothing. It is useful for embedding.

func (NullConnectionTracer) AcknowledgedPacket

func (n NullConnectionTracer) AcknowledgedPacket(EncryptionLevel, PacketNumber)

func (NullConnectionTracer) BufferedPacket

func (n NullConnectionTracer) BufferedPacket(PacketType, ByteCount)

func (NullConnectionTracer) Close

func (n NullConnectionTracer) Close()

func (NullConnectionTracer) ClosedConnection

func (n NullConnectionTracer) ClosedConnection(err error)

func (NullConnectionTracer) Debug

func (n NullConnectionTracer) Debug(name, msg string)

func (NullConnectionTracer) DroppedEncryptionLevel

func (n NullConnectionTracer) DroppedEncryptionLevel(EncryptionLevel)

func (NullConnectionTracer) DroppedKey

func (n NullConnectionTracer) DroppedKey(KeyPhase)

func (NullConnectionTracer) DroppedPacket

func (NullConnectionTracer) LossTimerCanceled

func (n NullConnectionTracer) LossTimerCanceled()

func (NullConnectionTracer) LossTimerExpired

func (n NullConnectionTracer) LossTimerExpired(timerType TimerType, level EncryptionLevel)

func (NullConnectionTracer) LostPacket

func (NullConnectionTracer) NegotiatedVersion

func (n NullConnectionTracer) NegotiatedVersion(chosen VersionNumber, clientVersions, serverVersions []VersionNumber)

func (NullConnectionTracer) ReceivedLongHeaderPacket

func (n NullConnectionTracer) ReceivedLongHeaderPacket(*ExtendedHeader, ByteCount, []Frame)

func (NullConnectionTracer) ReceivedRetry

func (n NullConnectionTracer) ReceivedRetry(*Header)

func (NullConnectionTracer) ReceivedShortHeaderPacket

func (n NullConnectionTracer) ReceivedShortHeaderPacket(*ShortHeader, ByteCount, []Frame)

func (NullConnectionTracer) ReceivedTransportParameters

func (n NullConnectionTracer) ReceivedTransportParameters(*TransportParameters)

func (NullConnectionTracer) ReceivedVersionNegotiationPacket

func (n NullConnectionTracer) ReceivedVersionNegotiationPacket(dest, src ArbitraryLenConnectionID, _ []VersionNumber)

func (NullConnectionTracer) RestoredTransportParameters

func (n NullConnectionTracer) RestoredTransportParameters(*TransportParameters)

func (NullConnectionTracer) SentPacket

func (NullConnectionTracer) SentTransportParameters

func (n NullConnectionTracer) SentTransportParameters(*TransportParameters)

func (NullConnectionTracer) SetLossTimer

func (NullConnectionTracer) StartedConnection

func (n NullConnectionTracer) StartedConnection(local, remote net.Addr, srcConnID, destConnID ConnectionID)

func (NullConnectionTracer) UpdatedCongestionState

func (n NullConnectionTracer) UpdatedCongestionState(CongestionState)

func (NullConnectionTracer) UpdatedKey

func (n NullConnectionTracer) UpdatedKey(keyPhase KeyPhase, remote bool)

func (NullConnectionTracer) UpdatedKeyFromTLS

func (n NullConnectionTracer) UpdatedKeyFromTLS(EncryptionLevel, Perspective)

func (NullConnectionTracer) UpdatedMetrics

func (n NullConnectionTracer) UpdatedMetrics(rttStats *RTTStats, cwnd, bytesInFlight ByteCount, packetsInFlight int)

func (NullConnectionTracer) UpdatedPTOCount

func (n NullConnectionTracer) UpdatedPTOCount(uint32)

type NullTracer

type NullTracer struct{}

The NullTracer is a Tracer that does nothing. It is useful for embedding.

func (NullTracer) DroppedPacket

func (NullTracer) SentPacket

func (n NullTracer) SentPacket(net.Addr, *Header, ByteCount, []Frame)

func (NullTracer) SentVersionNegotiationPacket

func (n NullTracer) SentVersionNegotiationPacket(_ net.Addr, dest, src ArbitraryLenConnectionID, _ []VersionNumber)

func (NullTracer) TracerForConnection

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 ShortHeader

type ShortHeader struct {
	DestConnectionID ConnectionID
	PacketNumber     PacketNumber
	PacketNumberLen  protocol.PacketNumberLen
	KeyPhase         KeyPhaseBit
}

The ShortHeader is the QUIC Short Header packet header, after removing header protection.

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)
	SentVersionNegotiationPacket(_ net.Addr, dest, src ArbitraryLenConnectionID, _ []VersionNumber)
	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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL