tracing

type Bytes []byte

type Conn interface {
	// Returns the protocol that this Conn value was constructed from.
	Protocol() ConnProtocol

	// Observe is called when a network event is received for this connection.
	//
	// The receiver is expected to update its state by capturing the data
	// fragments carried in the event.
	Observe(*Event)

	// After calls to Observe, the connection may receive a call to Next in
	// order to consume the next message that was formed by the accumulation of
	// data fragements from network events.
	//
	// The method writes to the Message value passed as argument, returning true
	// if a message could be formed, and false otherwise.
	Next(*Message) bool

	// Indicates whether the connection has reached EOF, and has no more
	// messages to read.
	Done() bool
}

type ConnMessage interface {
	// Returns the connection that the message was originally decoded from.
	Conn() Conn

	// Marshals the message into a representation intended to be marshaled to
	// structured formats like JSON or YAML.
	Marshal() any

	// Formats the message to a human readable format.
	fmt.Formatter
}

type ConnProtocol interface {
	// Returns the name of the protocol.
	//
	// This value is used when printing protocol messages in a human readable
	// format.
	Name() string

	// Given a data segment found at the beginning of a network connection,
	// determine whether the protocol is able to decode it.
	//
	// This method is used to do automatic detection of the protocol being used
	// when inspecting network events.
	CanHandle(data []byte) bool

	// Constructs a Conn instance intended to decode protocol messages exchanged
	// over a client connection.
	NewClient(fd wasi.FD, addr, peer net.Addr) Conn

	// Constructs a Conn instance intended to decode protocol messages exchanged
	// over a server connection.
	NewServer(fd wasi.FD, addr, peer net.Addr) Conn
}

type Event struct {
	Record int64      `json:"record"          yaml:"record"`
	Time   time.Time  `json:"time"            yaml:"time"`
	Type   EventType  `json:"type"            yaml:"type"`
	Proto  Protocol   `json:"proto"           yaml:"proto"`
	Error  wasi.Errno `json:"error,omitempty" yaml:"error,omitempty"`
	FD     wasi.FD    `json:"fd"              yaml:"fd"`
	Addr   net.Addr   `json:"addr,omitempty"  yaml:"addr,omitempty"`
	Peer   net.Addr   `json:"peer,omitempty"  yaml:"peer,omitempty"`
	Data   []Bytes    `json:"data,omitempty"  yaml:"data,omitempty"`
}

type EventReader struct {
	Records stream.Reader[timemachine.Record]
	// contains filtered or unexported fields
}

type EventType uint8

type Exchange struct {
	Link Link
	Req  Request
	Res  Response
}

type ExchangeReader struct {
	Messages stream.Reader[Message]
	// contains filtered or unexported fields
}

type Link struct {
	Src net.Addr `json:"src" yaml:"src"`
	Dst net.Addr `json:"dst" yaml:"dst"`
}

type Message struct {
	Link Link
	Time time.Time
	Span time.Duration
	Err  error
	// contains filtered or unexported fields
}

type MessageReader struct {
	Events stream.Reader[Event]
	Protos []ConnProtocol
	// contains filtered or unexported fields
}

type Protocol uint8

type Request struct {
	Time time.Time
	Span time.Duration
	Err  error
	// contains filtered or unexported fields
}

type Response struct {
	Time time.Duration
	Span time.Duration
	Err  error
	// contains filtered or unexported fields
}